From fa50fda276cd461bd8eaf33edf731a8799d81910 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 10 Dec 2024 22:17:11 +0100 Subject: [PATCH 01/19] Expanded exisitng envs validation logic into extensive validation mechanism for options from all sources. --- lib/envs.js | 258 ----- lib/validation.js | 2802 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2802 insertions(+), 258 deletions(-) delete mode 100644 lib/envs.js create mode 100644 lib/validation.js diff --git a/lib/envs.js b/lib/envs.js deleted file mode 100644 index c3ab2f49..00000000 --- a/lib/envs.js +++ /dev/null @@ -1,258 +0,0 @@ -/******************************************************************************* - -Highcharts Export Server - -Copyright (c) 2016-2024, Highsoft - -Licenced under the MIT licence. - -Additionally a valid Highcharts license is required for use. - -See LICENSE file in root for details. - -*******************************************************************************/ - -/** - * @overview This file is responsible for parsing the environment variables - * with the 'zod' library. The parsed environment variables are then exported - * to be used in the application as "envs". We should not use the `process.env` - * directly in the application as these would not be parsed properly. - * - * The environment variables are parsed and validated only once when - * the application starts. We should write a custom validator or a transformer - * for each of the options. - */ - -import dotenv from 'dotenv'; -import { z } from 'zod'; - -import { defaultConfig } from './schemas/config.js'; - -// Load .env into environment variables -dotenv.config(); - -// Object with custom validators and transformers, to avoid repetition -// in the Config object -const v = { - // Splits string value into elements in an array, trims every element, checks - // if an array is correct, if it is empty, and if it is, returns undefined - array: (filterArray) => - z - .string() - .transform((value) => - value - .split(',') - .map((value) => value.trim()) - .filter((value) => filterArray.includes(value)) - ) - .transform((value) => (value.length ? value : undefined)), - - // Allows only true, false and correctly parse the value to boolean - // or no value in which case the returned value will be undefined - boolean: () => - z - .enum(['true', 'false', '']) - .transform((value) => (value !== '' ? value === 'true' : undefined)), - - // Allows passed values or no value in which case the returned value will - // be undefined - enum: (values) => - z - .enum([...values, '']) - .transform((value) => (value !== '' ? value : undefined)), - - // Trims the string value and checks if it is empty or contains stringified - // values such as false, undefined, null, NaN, if it does, returns undefined - string: () => - z - .string() - .trim() - .refine( - (value) => - !['false', 'undefined', 'null', 'NaN'].includes(value) || - value === '', - (value) => ({ - message: `The string contains forbidden values, received '${value}'` - }) - ) - .transform((value) => (value !== '' ? value : undefined)), - - // Allows positive numbers or no value in which case the returned value will - // be undefined - positiveNum: () => - z - .string() - .trim() - .refine( - (value) => - value === '' || (!isNaN(parseFloat(value)) && parseFloat(value) > 0), - (value) => ({ - message: `The value must be numeric and positive, received '${value}'` - }) - ) - .transform((value) => (value !== '' ? parseFloat(value) : undefined)), - - // Allows non-negative numbers or no value in which case the returned value - // will be undefined - nonNegativeNum: () => - z - .string() - .trim() - .refine( - (value) => - value === '' || (!isNaN(parseFloat(value)) && parseFloat(value) >= 0), - (value) => ({ - message: `The value must be numeric and non-negative, received '${value}'` - }) - ) - .transform((value) => (value !== '' ? parseFloat(value) : undefined)) -}; - -export const Config = z.object({ - // puppeteer - PUPPETEER_ARGS: v.string(), - - // highcharts - HIGHCHARTS_VERSION: z - .string() - .trim() - .refine( - (value) => /^(latest|\d+(\.\d+){0,2})$/.test(value) || value === '', - (value) => ({ - message: `HIGHCHARTS_VERSION must be 'latest', a major version, or in the form XX.YY.ZZ, received '${value}'` - }) - ) - .transform((value) => (value !== '' ? value : undefined)), - HIGHCHARTS_CDN_URL: z - .string() - .trim() - .refine( - (value) => - value.startsWith('https://') || - value.startsWith('http://') || - value === '', - (value) => ({ - message: `Invalid value for HIGHCHARTS_CDN_URL. It should start with http:// or https://, received '${value}'` - }) - ) - .transform((value) => (value !== '' ? value : undefined)), - HIGHCHARTS_FORCE_FETCH: v.boolean(), - HIGHCHARTS_CACHE_PATH: v.string(), - HIGHCHARTS_ADMIN_TOKEN: v.string(), - HIGHCHARTS_CORE_SCRIPTS: v.array(defaultConfig.highcharts.coreScripts), - HIGHCHARTS_MODULE_SCRIPTS: v.array(defaultConfig.highcharts.moduleScripts), - HIGHCHARTS_INDICATOR_SCRIPTS: v.array( - defaultConfig.highcharts.indicatorScripts - ), - HIGHCHARTS_CUSTOM_SCRIPTS: v.array(defaultConfig.highcharts.customScripts), - - // export - EXPORT_INFILE: v.string(), - EXPORT_INSTR: v.string(), - EXPORT_OPTIONS: v.string(), - EXPORT_SVG: v.string(), - EXPORT_OUTFILE: v.string(), - EXPORT_TYPE: v.enum(['jpeg', 'png', 'pdf', 'svg']), - EXPORT_CONSTR: v.enum(['chart', 'stockChart', 'mapChart', 'ganttChart']), - EXPORT_B64: v.boolean(), - EXPORT_NO_DOWNLOAD: v.boolean(), - EXPORT_HEIGHT: v.positiveNum(), - EXPORT_WIDTH: v.positiveNum(), - EXPORT_SCALE: v.positiveNum(), - EXPORT_DEFAULT_HEIGHT: v.positiveNum(), - EXPORT_DEFAULT_WIDTH: v.positiveNum(), - EXPORT_DEFAULT_SCALE: v.positiveNum(), - EXPORT_GLOBAL_OPTIONS: v.string(), - EXPORT_THEME_OPTIONS: v.string(), - EXPORT_BATCH: v.string(), - EXPORT_RASTERIZATION_TIMEOUT: v.nonNegativeNum(), - - // custom - CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: v.boolean(), - CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: v.boolean(), - CUSTOM_LOGIC_CUSTOM_CODE: v.string(), - CUSTOM_LOGIC_CALLBACK: v.string(), - CUSTOM_LOGIC_RESOURCES: v.string(), - CUSTOM_LOGIC_LOAD_CONFIG: v.string(), - CUSTOM_LOGIC_CREATE_CONFIG: v.string(), - - // server - SERVER_ENABLE: v.boolean(), - SERVER_HOST: v.string(), - SERVER_PORT: v.positiveNum(), - SERVER_BENCHMARKING: v.boolean(), - - // server proxy - SERVER_PROXY_HOST: v.string(), - SERVER_PROXY_PORT: v.positiveNum(), - SERVER_PROXY_TIMEOUT: v.nonNegativeNum(), - - // server rate limiting - SERVER_RATE_LIMITING_ENABLE: v.boolean(), - SERVER_RATE_LIMITING_MAX_REQUESTS: v.nonNegativeNum(), - SERVER_RATE_LIMITING_WINDOW: v.nonNegativeNum(), - SERVER_RATE_LIMITING_DELAY: v.nonNegativeNum(), - SERVER_RATE_LIMITING_TRUST_PROXY: v.boolean(), - SERVER_RATE_LIMITING_SKIP_KEY: v.string(), - SERVER_RATE_LIMITING_SKIP_TOKEN: v.string(), - - // server ssl - SERVER_SSL_ENABLE: v.boolean(), - SERVER_SSL_FORCE: v.boolean(), - SERVER_SSL_PORT: v.positiveNum(), - SERVER_SSL_CERT_PATH: v.string(), - - // pool - POOL_MIN_WORKERS: v.nonNegativeNum(), - POOL_MAX_WORKERS: v.nonNegativeNum(), - POOL_WORK_LIMIT: v.positiveNum(), - POOL_ACQUIRE_TIMEOUT: v.nonNegativeNum(), - POOL_CREATE_TIMEOUT: v.nonNegativeNum(), - POOL_DESTROY_TIMEOUT: v.nonNegativeNum(), - POOL_IDLE_TIMEOUT: v.nonNegativeNum(), - POOL_CREATE_RETRY_INTERVAL: v.nonNegativeNum(), - POOL_REAPER_INTERVAL: v.nonNegativeNum(), - POOL_BENCHMARKING: v.boolean(), - - // logger - LOGGING_LEVEL: z - .string() - .trim() - .refine( - (value) => - value === '' || - (!isNaN(parseFloat(value)) && - parseFloat(value) >= 0 && - parseFloat(value) <= 5), - (value) => ({ - message: `Invalid value for LOGGING_LEVEL. We only accept values from 0 to 5 as logging levels, received '${value}'` - }) - ) - .transform((value) => (value !== '' ? parseFloat(value) : undefined)), - LOGGING_FILE: v.string(), - LOGGING_DEST: v.string(), - LOGGING_TO_CONSOLE: v.boolean(), - LOGGING_TO_FILE: v.boolean(), - - // ui - UI_ENABLE: v.boolean(), - UI_ROUTE: v.string(), - - // other - OTHER_NODE_ENV: v.enum(['development', 'production', 'test']), - OTHER_LISTEN_TO_PROCESS_EXITS: v.boolean(), - OTHER_NO_LOGO: v.boolean(), - OTHER_HARD_RESET_PAGE: v.boolean(), - OTHER_BROWSER_SHELL_MODE: v.boolean(), - - // debugger - DEBUG_ENABLE: v.boolean(), - DEBUG_HEADLESS: v.boolean(), - DEBUG_DEVTOOLS: v.boolean(), - DEBUG_LISTEN_TO_CONSOLE: v.boolean(), - DEBUG_DUMPIO: v.boolean(), - DEBUG_SLOW_MO: v.nonNegativeNum(), - DEBUG_DEBUGGING_PORT: v.positiveNum() -}); - -export const envs = Config.partial().parse(process.env); diff --git a/lib/validation.js b/lib/validation.js new file mode 100644 index 00000000..1cfc327d --- /dev/null +++ b/lib/validation.js @@ -0,0 +1,2802 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +/** + * @overview This file handles parsing and validating options from multiple + * sources (the config file, custom JSON, environment variables, CLI arguments, + * and request payload) using the 'zod' library. + * + * Environment variables are parsed and validated only once at application + * startup, and the validated results are exported as `envs` for use throughout + * the application. + * + * Options from other sources, however, are parsed and validated on demand, + * each time an export is attempted. + */ + +import dotenv from 'dotenv'; +import { z } from 'zod'; + +import { defaultConfig } from './schemas/config.js'; + +// Load the .env into environment variables +dotenv.config(); + +// Get scripts names of each category from the default config +const { coreScripts, moduleScripts, indicatorScripts } = + defaultConfig.highcharts; + +// Sets the custom error map globally +z.setErrorMap(_customErrorMap); + +/** + * Object containing custom general validators and parsers to avoid repetition + * in schema objects. All validators apply to values from various sources, + * including the default config file, a custom JSON file loaded with the option + * called `loadConfig`, the .env file, CLI arguments, and the request payload. + * The `strictCheck` flag enables stricter validation and parsing rules. This + * flag is set to false for values that come from the .env file or CLI arguments + * because they are provided as strings and need to be parsed accordingly first. + */ +const v = { + /** + * The `boolean` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept values are true + * and false and the schema will validate against the default boolean + * validator. + * + * - When `strictCheck` is false, the schema will accept values are true, + * false, null, 'true', 'false', 'undefined', 'null', and ''. The strings + * 'undefined', 'null', and '' will be transformed to null, the string 'true' + * will be transformed to the boolean value true, and 'false' will + * be transformed to the boolean value false. + * + * @function boolean + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating boolean values. + */ + boolean(strictCheck) { + return strictCheck + ? z.boolean() + : z + .union([ + z + .enum(['true', 'false', 'undefined', 'null', '']) + .transform((value) => + !['undefined', 'null', ''].includes(value) + ? value === 'true' + : null + ), + z.boolean() + ]) + .nullable(); + }, + + /** + * The `string` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept trimmed strings except + * the forbidden values: 'false', 'undefined', 'null', and ''. + * + * - When `strictCheck` is false, the schema will accept trimmed strings + * and null. The forbidden values: 'false', 'undefined', 'null', and '' will + * be transformed to null. + * + * @function string + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating string values. + */ + string(strictCheck) { + return strictCheck + ? z + .string() + .trim() + .refine( + (value) => !['false', 'undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The string contains a forbidden value` + } + } + ) + : z + .string() + .trim() + .transform((value) => + !['false', 'undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `enum` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The schema will validate against the provided `values` array. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will validate against the `values` + * array with the default enum validator. + * + * - When `strictCheck` is false, the schema will accept also null, + * 'undefined', 'null', and '', which will be transformed to null. + * + * @function enum + * + * @param {Array.} values - An array of valid string values + * for the enum. + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating enum values. + */ + enum(values, strictCheck) { + return strictCheck + ? z.enum([...values]) + : z + .enum([...values, 'undefined', 'null', '']) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `stringArray` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept an array of trimmed + * string values filtered by the logic provided through the `filterCallback`. + * + * - When `strictCheck` is false, the schema will accept null and trimmed + * string values which will be splitted into an array of strings and filtered + * from the '[' and ']' characters and by the logic provided through + * the `filterCallback`. If the array is empty, it will be transformed + * to null. + * + * @function stringArray + * + * @param {function} filterCallback - The filter callback. + * @param {string} separator - The separator for spliting a string. + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating array of string + * values. + */ + stringArray(filterCallback, separator, strictCheck) { + const arraySchema = z.string().trim().array(); + const stringSchema = z + .string() + .trim() + .transform((value) => { + if (value.startsWith('[')) { + value = value.slice(1); + } + if (value.endsWith(']')) { + value = value.slice(0, -1); + } + return value.split(separator); + }); + + const transformCallback = (value) => + value.map((value) => value.trim()).filter(filterCallback); + + return strictCheck + ? arraySchema.transform(transformCallback) + : z + .union([stringSchema, arraySchema]) + .transform(transformCallback) + .transform((value) => (value.length ? value : null)) + .nullable(); + }, + + /** + * The `positiveNum` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept positive number values + * and validate against the default positive number validator. + * + * - When `strictCheck` is false, the schema will accept positive number + * values, null, and trimmed string values that can either be 'undefined', + * 'null', '', or represent a positive number. It will transform the string + * to a positive number, or to null if it is 'undefined', 'null', or ''. + * + * @function positiveNum + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating positive number + * values. + */ + positiveNum(strictCheck) { + return strictCheck + ? z.number().positive() + : z + .union([ + z + .string() + .trim() + .refine( + (value) => + (!isNaN(Number(value)) && Number(value) > 0) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be numeric and positive` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) + ? Number(value) + : null + ), + z.number().positive() + ]) + .nullable(); + }, + + /** + * The `nonNegativeNum` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept non-negative number + * values and validate against the default non-negative number validator. + * + * - When `strictCheck` is false, the schema will accept non-negative number + * values, null, and trimmed string values that can either be 'undefined', + * 'null', '', or represent a non-negative number. It will transform + * the string to a non-negative number, or to null if it is 'undefined', + * 'null', or ''. + * + * @function nonNegativeNum + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating non-negative + * number values. + */ + nonNegativeNum(strictCheck) { + return strictCheck + ? z.number().nonnegative() + : z + .union([ + z + .string() + .trim() + .refine( + (value) => + (!isNaN(Number(value)) && Number(value) >= 0) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be numeric and non-negative` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) + ? Number(value) + : null + ), + z.number().nonnegative() + ]) + .nullable(); + }, + + /** + * The `startsWith` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The schema will validate against the provided `prefixes` array to check + * whether a string value starts with any of the values provided + * in the `prefixes` array. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept trimmed string values + * that start with values from the prefixes array. + * + * - When `strictCheck` is false, the schema will accept trimmed string values + * that start with values from the prefixes array, null, 'undefined', 'null', + * and '' where the schema will transform them to null. + * + * @function startsWith + * + * @param {Array.} prefixes - An array of prefixes to validate + * the string against. + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating strings that + * starts with values. + */ + startsWith(prefixes, strictCheck) { + return strictCheck + ? z + .string() + .trim() + .refine( + (value) => prefixes.some((prefix) => value.startsWith(prefix)), + { + params: { + errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}` + } + } + ) + : z + .string() + .trim() + .refine( + (value) => + prefixes.some((prefix) => value.startsWith(prefix)) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `chartConfig` validator that returns a Zod schema. + * + * The validation schema ensures that the schema will accept object values + * or trimmed string values that contain ' + value.indexOf('= 0 || + value.indexOf('= 0 || + (value.startsWith('{') && value.endsWith('}')) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that contains ' + !['undefined', 'null', ''].includes(value) ? value : null + ), + z.object({}).passthrough() + ]) + .nullable(); + }, + + /** + * The `additionalOptions` validator that returns a Zod schema. + * + * The validation schema ensures that the schema will accept object values + * or trimmed string values that end with '.json' and are at least one + * character long excluding the extension, start with the '{' and end + * with the '}', and null. The 'undefined', 'null', and '' values will + * be transformed to null. + * + * @function additionalOptions + * + * @returns {z.ZodSchema} A Zod schema object for validating additional chart + * options value. + */ + additionalOptions() { + return z + .union([ + z + .string() + .trim() + .refine( + (value) => + (value.length >= 6 && value.endsWith('.json')) || + (value.startsWith('{') && value.endsWith('}')) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that ends with '.json' or starts with '{' and ends with '}'` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ), + z.object({}).passthrough() + ]) + .nullable(); + } +}; + +/** + * Object containing custom config validators and parsers to avoid repetition + * in schema objects. All validators apply to values from various sources, + * including the default config file, a custom JSON file loaded with the option + * called `loadConfig`, the .env file, CLI arguments, and the request payload. + * The `strictCheck` flag enables stricter validation and parsing rules. This + * flag is set to false for values that come from the .env file or CLI arguments + * because they are provided as strings and need to be parsed accordingly first. + */ +const config = { + /** + * The `args` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `stringArray` validator. + * + * @function args + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `args` + * option. + */ + args(strictCheck) { + return v.stringArray( + (value) => !['false', 'undefined', 'null', ''].includes(value), + ';', + strictCheck + ); + }, + + /** + * The `version` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept trimmed string values + * that are a RegExp-based that allows to be 'latest', or in the format XX, + * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts + * version option. + * + * - When `strictCheck` is false, the schema will accept also null, + * 'undefined', 'null', or '' and in all cases the schema will transform them + * to null. + * + * @function version + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `version` + * option. + */ + version(strictCheck) { + return strictCheck + ? z + .string() + .trim() + .refine((value) => /^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(value), { + params: { + errorMessage: + "The value must be 'latest', a major version, or in the form XX.YY.ZZ" + } + }) + : z + .string() + .trim() + .refine( + (value) => + /^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(value) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: + "The value must be 'latest', a major version, or in the form XX.YY.ZZ" + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `cdnUrl` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `startsWith` validator. + * + * @function cdnUrl + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl` + * option. + */ + cdnUrl(strictCheck) { + return v.startsWith(['http://', 'https://'], strictCheck); + }, + + /** + * The `forceFetch` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function forceFetch + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch` + * option. + */ + forceFetch(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `cachePath` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function cachePath + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath` + * option. + */ + cachePath(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `adminToken` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function adminToken + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken` + * option. + */ + adminToken(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `coreScripts` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `stringArray` validator. + * + * @function coreScripts + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts` + * option. + */ + coreScripts(strictCheck) { + return v.stringArray( + (value) => coreScripts.value.includes(value), + ',', + strictCheck + ); + }, + + /** + * The `moduleScripts` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `stringArray` validator. + * + * @function moduleScripts + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `moduleScripts` option. + */ + moduleScripts(strictCheck) { + return v.stringArray( + (value) => moduleScripts.value.includes(value), + ',', + strictCheck + ); + }, + + /** + * The `indicatorScripts` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `stringArray` validator. + * + * @function indicatorScripts + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `indicatorScripts` option. + */ + indicatorScripts(strictCheck) { + return v.stringArray( + (value) => indicatorScripts.value.includes(value), + ',', + strictCheck + ); + }, + + /** + * The `customScripts` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `stringArray` validator. + * + * @function customScripts + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `customScripts` option. + */ + customScripts(strictCheck) { + return v.stringArray( + (value) => value.startsWith('https://') || value.startsWith('http://'), + ',', + strictCheck + ); + }, + + /** + * The `infile` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept trimmed string values + * that end with '.json' or '.svg', are at least one character long excluding + * the extension, or null. + * + * - When `strictCheck` is false, the schema will accept trimmed string values + * that end with '.json' or '.svg', are at least one character long excluding + * the extension and will be null if the provided value is null, 'undefined', + * 'null', or ''. + * + * @function infile + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `infile` + * option. + */ + infile(strictCheck) { + return strictCheck + ? z + .string() + .trim() + .refine( + (value) => + (value.length >= 6 && value.endsWith('.json')) || + (value.length >= 5 && value.endsWith('.svg')), + { + params: { + errorMessage: `The value must be a string that ends with .json or .svg` + } + } + ) + .nullable() + : z + .string() + .trim() + .refine( + (value) => + (value.length >= 6 && value.endsWith('.json')) || + (value.length >= 5 && value.endsWith('.svg')) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that ends with .json or .svg` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `instr` validator that returns a Zod schema. + * + * The validation schema ensures the same work as the `options` validator. + * + * @function instr + * + * @returns {z.ZodSchema} A Zod schema object for validating the `instr` + * option. + */ + instr() { + return v.chartConfig(); + }, + + /** + * The `options` validator that returns a Zod schema. + * + * The validation schema ensures the same work as the `options` validator. + * + * @function options + * + * @returns {z.ZodSchema} A Zod schema object for validating the `options` + * option. + */ + options() { + return v.chartConfig(); + }, + + /** + * The `svg` validator that returns a Zod schema. + * + * The validation schema ensures that the schema will accept object values + * or trimmed string values that contain ' + value.indexOf('= 0 || + value.indexOf('= 0 || + ['false', 'undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that contains ' + !['false', 'undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `outfile` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept trimmed string values + * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one + * character long excluding the extension, or null. + * + * - When `strictCheck` is false, the schema will accept trimmed string values + * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one + * character long excluding the extension and will be null if the provided + * value is null, 'undefined', 'null', or ''. + * + * @function outfile + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `outfile` + * option. + */ + outfile(strictCheck) { + return strictCheck + ? z + .string() + .trim() + .refine( + (value) => + (value.length >= 6 && value.endsWith('.jpeg')) || + (value.length >= 5 && + (value.endsWith('.jpg') || + value.endsWith('.png') || + value.endsWith('.pdf') || + value.endsWith('.svg'))), + { + params: { + errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg` + } + } + ) + .nullable() + : z + .string() + .trim() + .refine( + (value) => + (value.length >= 6 && value.endsWith('.jpeg')) || + (value.length >= 5 && + (value.endsWith('.jpg') || + value.endsWith('.png') || + value.endsWith('.pdf') || + value.endsWith('.svg'))) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ) + .nullable(); + }, + + /** + * The `type` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `enum` validator. + * + * @function type + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `type` + * option. + */ + type(strictCheck) { + return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck); + }, + + /** + * The `constr` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `enum` validator. + * + * @function constr + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `constr` + * option. + */ + constr(strictCheck) { + return v.enum( + ['chart', 'stockChart', 'mapChart', 'ganttChart'], + strictCheck + ); + }, + + /** + * The `b64` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function b64 + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option. + */ + b64(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `noDownload` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function noDownload + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload` + * option. + */ + noDownload(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `defaultHeight` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `positiveNum` validator. + * + * @function defaultHeight + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `defaultHeight` option. + */ + defaultHeight(strictCheck) { + return v.positiveNum(strictCheck); + }, + + /** + * The `defaultWidth` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `positiveNum` validator. + * + * @function defaultWidth + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `defaultWidth` option. + */ + defaultWidth(strictCheck) { + return v.positiveNum(strictCheck); + }, + + /** + * The `defaultScale` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept number values that + * are between 0.1 and 5 (inclusive). + * + * - When `strictCheck` is false, the schema will accept number values + * and stringified number values that are between 0.1 and 5 (inclusive), null, + * 'undefined', 'null', and '' which will be transformed to null. + * + * @function defaultScale + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `defaultScale` option. + */ + defaultScale(strictCheck) { + return strictCheck + ? z.number().gte(0.1).lte(5) + : z + .union([ + z + .string() + .trim() + .refine( + (value) => + (!isNaN(Number(value)) && + value !== true && + !value.startsWith('[') && + Number(value) >= 0.1 && + Number(value) <= 5) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: 'The value must be within a 0.1 and 5.0 range' + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) + ? Number(value) + : null + ), + z.number().gte(0.1).lte(5) + ]) + .nullable(); + }, + + /** + * The `height` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as a nullable `defaultHeight` + * validator. + * + * @function height + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `height` + * option. + */ + height(strictCheck) { + return this.defaultHeight(strictCheck).nullable(); + }, + + /** + * The `width` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as a nullable `defaultWidth` + * validator. + * + * @function width + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `width` + * option. + */ + width(strictCheck) { + return this.defaultWidth(strictCheck).nullable(); + }, + + /** + * The `scale` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as a nullable `defaultScale` + * validator. + * + * @function scale + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `scale` + * option. + */ + scale(strictCheck) { + return this.defaultScale(strictCheck).nullable(); + }, + + /** + * The `globalOptions` validator that returns a Zod schema. + * + * The validation schema ensures the same work as the `additionalOptions` + * validator. + * + * @function globalOptions + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `globalOptions` option. + */ + globalOptions() { + return v.additionalOptions(); + }, + + /** + * The `themeOptions` validator that returns a Zod schema. + * + * The validation schema ensures the same work as the `additionalOptions` + * validator. + * + * @function themeOptions + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `themeOptions` option. + */ + themeOptions() { + return v.additionalOptions(); + }, + + /** + * The `batch` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function batch + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `batch` + * option. + */ + batch(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `rasterizationTimeout` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function rasterizationTimeout + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `rasterizationTimeout` option. + */ + rasterizationTimeout(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `allowCodeExecution` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function allowCodeExecution + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `allowCodeExecution` option. + */ + allowCodeExecution(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `allowFileResources` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function allowFileResources + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `allowFileResources` option. + */ + allowFileResources(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `customCode` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function customCode + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `customCode` + * option. + */ + customCode(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `callback` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function callback + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `callback` + * option. + */ + callback(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `resources` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept a partial object + * with allowed properties `js`, `css`, and `files` where each of the allowed + * properties can be null, stringified version of the object, string that ends + * with the '.json', and null. + * + * - When `strictCheck` is false, the schema will accept a stringified version + * of a partial object with allowed properties `js`, `css`, and `files` where + * each of the allowed properties can be null, string that ends with the + * '.json', and will be null if the provided value is 'undefined', 'null' + * or ''. + * + * @function resources + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `resources` + * option. + */ + resources(strictCheck) { + const objectSchema = z + .object({ + js: v.string(false), + css: v.string(false), + files: v + .stringArray( + (value) => !['undefined', 'null', ''].includes(value), + ',', + true + ) + .nullable() + }) + .partial(); + + const stringSchema1 = z + .string() + .trim() + .refine( + (value) => + (value.startsWith('{') && value.endsWith('}')) || + (value.length >= 6 && value.endsWith('.json')), + { + params: { + errorMessage: `The value must be a string that starts with '{' and ends with '}` + } + } + ); + + const stringSchema2 = z + .string() + .trim() + .refine( + (value) => + (value.startsWith('{') && value.endsWith('}')) || + (value.length >= 6 && value.endsWith('.json')) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: `The value must be a string that ends with '.json'` + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) ? value : null + ); + + return strictCheck + ? z.union([objectSchema, stringSchema1]).nullable() + : z.union([objectSchema, stringSchema2]).nullable(); + }, + + /** + * The `loadConfig` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * Additionally, it must be a string that ends with '.json'. + * + * @function loadConfig + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig` + * option. + */ + loadConfig(strictCheck) { + return v + .string(strictCheck) + .refine( + (value) => + value === null || (value.length >= 6 && value.endsWith('.json')), + { + params: { + errorMessage: `The value must be a string that ends with .json ` + } + } + ); + }, + + /** + * The `createConfig` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `loadConfig` validator. + * + * @function createConfig + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `createConfig` option. + */ + createConfig(strictCheck) { + return this.loadConfig(strictCheck); + }, + + /** + * The `enableServer` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function enableServer + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `enableServer` option. + */ + enableServer(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `host` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function host + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `host` + * option. + */ + host(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `port` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function port + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `port` + * option. + */ + port(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `serverBenchmarking` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function serverBenchmarking + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `serverBenchmarking` option. + */ + serverBenchmarking(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `proxyHost` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function proxyHost + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost` + * option. + */ + proxyHost(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `proxyPort` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as a nullable `nonNegativeNum` + * validator. + * + * @function proxyPort + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort` + * option. + */ + proxyPort(strictCheck) { + return v.nonNegativeNum(strictCheck).nullable(); + }, + + /** + * The `proxyTimeout` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function proxyTimeout + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `proxyTimeout` option. + */ + proxyTimeout(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `enableRateLimiting` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function enableRateLimiting + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `enableRateLimiting` option. + */ + enableRateLimiting(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `maxRequests` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function maxRequests + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests` + * option. + */ + maxRequests(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `window` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function window + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `window` + * option. + */ + window(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `delay` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function delay + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `delay` + * option. + */ + delay(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `trustProxy` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function trustProxy + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy` + * option. + */ + trustProxy(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `skipKey` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function skipKey + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey` + * option. + */ + skipKey(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `skipToken` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function skipToken + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken` + * option. + */ + skipToken(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `enableSsl` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function enableSsl + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl` + * option. + */ + enableSsl(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `sslForce` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function sslForce + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce` + * option. + */ + sslForce(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `sslPort` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function sslPort + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort` + * option. + */ + sslPort(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `sslCertPath` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function sslCertPath + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath` + * option. + */ + sslCertPath(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `minWorkers` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `positiveNum` validator. + * + * @function minWorkers + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers` + * option. + */ + minWorkers(strictCheck) { + return v.positiveNum(strictCheck); + }, + + /** + * The `maxWorkers` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `positiveNum` validator. + * + * @function maxWorkers + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers` + * option. + */ + maxWorkers(strictCheck) { + return v.positiveNum(strictCheck); + }, + + /** + * The `workLimit` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `positiveNum` validator. + * + * @function workLimit + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit` + * option. + */ + workLimit(strictCheck) { + return v.positiveNum(strictCheck); + }, + + /** + * The `acquireTimeout` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function acquireTimeout + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `acquireTimeout` option. + */ + acquireTimeout(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `createTimeout` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function createTimeout + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `createTimeout` option. + */ + createTimeout(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `destroyTimeout` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function destroyTimeout + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `destroyTimeout` option. + */ + destroyTimeout(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `idleTimeout` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function idleTimeout + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `idleTimeout` option. + */ + idleTimeout(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `createRetryInterval` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function createRetryInterval + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `createRetryInterval` option. + */ + createRetryInterval(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `reaperInterval` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function reaperInterval + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `reaperInterval` option. + */ + reaperInterval(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `poolBenchmarking` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function poolBenchmarking + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `poolBenchmarking` option. + */ + poolBenchmarking(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `resourcesInterval` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function resourcesInterval + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `resourcesInterval` option. + */ + resourcesInterval(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `logLevel` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures that: + * + * - When `strictCheck` is true, the schema will accept integer number values + * that are between 0 and 5 (inclusive). + * + * - When `strictCheck` is false, the schema will accept integer number values + * and stringified integer number values that are between 1 and 5 (inclusive), + * null, 'undefined', 'null', and '' which will be transformed to null. + * + * @function logLevel + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel` + * option. + */ + logLevel(strictCheck) { + return strictCheck + ? z.number().int().gte(0).lte(5) + : z + .union([ + z + .string() + .trim() + .refine( + (value) => + (!isNaN(Number(value)) && + value !== true && + !value.startsWith('[') && + Number.isInteger(Number(value)) && + Number(value) >= 0 && + Number(value) <= 5) || + ['undefined', 'null', ''].includes(value), + { + params: { + errorMessage: 'The value must be within a 0 and 5 range' + } + } + ) + .transform((value) => + !['undefined', 'null', ''].includes(value) + ? Number(value) + : null + ), + z.number().int().gte(0).lte(5) + ]) + .nullable(); + }, + + /** + * The `logFile` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * Additionally, it must be a string that ends with '.log'. + * + * @function logFile + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `logFile` + * option. + */ + logFile(strictCheck) { + return v + .string(strictCheck) + .refine( + (value) => + value === null || (value.length >= 5 && value.endsWith('.log')), + { + params: { + errorMessage: `The value must be a string that ends with '.log'` + } + } + ); + }, + + /** + * The `logDest` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * + * @function logDest + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `logDest` + * option. + */ + logDest(strictCheck) { + return v.string(strictCheck); + }, + + /** + * The `logToConsole` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function logToConsole + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `logToConsole` option. + */ + logToConsole(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `logToFile` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function logToFile + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile` + * option. + */ + logToFile(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `enableUi` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function enableUi + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi` + * option. + */ + enableUi(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `uiRoute` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `startsWith` validator. + * + * @function uiRoute + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute` + * option. + */ + uiRoute(strictCheck) { + return v.startsWith(['/'], strictCheck); + }, + + /** + * The `nodeEnv` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `enum` validator. + * + * @function nodeEnv + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv` + * option. + */ + nodeEnv(strictCheck) { + return v.enum(['development', 'production', 'test'], strictCheck); + }, + + /** + * The `listenToProcessExits` validator that returns a Zod schema with + * an optional stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function listenToProcessExits + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `listenToProcessExits` option. + */ + listenToProcessExits(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `noLogo` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function noLogo + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo` + * option. + */ + noLogo(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `hardResetPage` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function hardResetPage + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `hardResetPage` option. + */ + hardResetPage(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `browserShellMode` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function browserShellMode + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `browserShellMode` option. + */ + browserShellMode(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `enableDebug` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function enableDebug + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug` + * option. + */ + enableDebug(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `headless` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function headless + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `headless` + * option. + */ + headless(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `devtools` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function devtools + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `devtools` + * option. + */ + devtools(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `listenToConsole` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function listenToConsole + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `listenToConsole` option. + */ + listenToConsole(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `dumpio` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function dumpio + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio` + * option. + */ + dumpio(strictCheck) { + return v.boolean(strictCheck); + }, + + /** + * The `slowMo` validator that returns a Zod schema with an optional stricter + * check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function slowMo + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo` + * option. + */ + slowMo(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `debuggingPort` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `nonNegativeNum` + * validator. + * + * @function debuggingPort + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating + * the `debuggingPort` option. + */ + debuggingPort(strictCheck) { + return v.nonNegativeNum(strictCheck); + }, + + /** + * The `requestId` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `string` validator. + * Additionally, it must be a stringified UUID or can be null. + * + * @function requestId + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `requestId` + * option. + */ + requestId() { + return ( + z + .string() + /// TO DO: Correct + .uuid({ message: 'The value must be a stringified UUID' }) + .nullable() + ); + } +}; + +// Schema for the puppeteer section of options +const PuppeteerSchema = (strictCheck) => + z + .object({ + args: config.args(strictCheck) + }) + .partial(); + +// Schema for the highcharts section of options +const HighchartsSchema = (strictCheck) => + z + .object({ + version: config.version(strictCheck), + cdnUrl: config.cdnUrl(strictCheck), + forceFetch: config.forceFetch(strictCheck), + cachePath: config.cachePath(strictCheck), + coreScripts: config.coreScripts(strictCheck), + moduleScripts: config.moduleScripts(strictCheck), + indicatorScripts: config.indicatorScripts(strictCheck), + customScripts: config.customScripts(strictCheck) + }) + .partial(); + +// Schema for the export section of options +const ExportSchema = (strictCheck) => + z + .object({ + infile: config.infile(strictCheck), + instr: config.instr(), + options: config.options(), + svg: config.svg(), + outfile: config.outfile(strictCheck), + type: config.type(strictCheck), + constr: config.constr(strictCheck), + b64: config.b64(strictCheck), + noDownload: config.noDownload(strictCheck), + defaultHeight: config.defaultHeight(strictCheck), + defaultWidth: config.defaultWidth(strictCheck), + defaultScale: config.defaultScale(strictCheck), + height: config.height(strictCheck), + width: config.width(strictCheck), + scale: config.scale(strictCheck), + globalOptions: config.globalOptions(), + themeOptions: config.themeOptions(), + batch: config.batch(false), + rasterizationTimeout: config.rasterizationTimeout(strictCheck) + }) + .partial(); + +// Schema for the customLogic section of options +const CustomLogicSchema = (strictCheck) => + z + .object({ + allowCodeExecution: config.allowCodeExecution(strictCheck), + allowFileResources: config.allowFileResources(strictCheck), + customCode: config.customCode(false), + callback: config.callback(false), + resources: config.resources(strictCheck), + loadConfig: config.loadConfig(false), + createConfig: config.createConfig(false) + }) + .partial(); + +// Schema for the server.proxy section of options +const ProxySchema = (strictCheck) => + z + .object({ + host: config.proxyHost(false), + port: config.proxyPort(strictCheck), + timeout: config.proxyTimeout(strictCheck) + }) + .partial(); + +// Schema for the server.rateLimiting section of options +const RateLimitingSchema = (strictCheck) => + z + .object({ + enable: config.enableRateLimiting(strictCheck), + maxRequests: config.maxRequests(strictCheck), + window: config.window(strictCheck), + delay: config.delay(strictCheck), + trustProxy: config.trustProxy(strictCheck), + skipKey: config.skipKey(false), + skipToken: config.skipToken(false) + }) + .partial(); + +// Schema for the server.ssl section of options +const SslSchema = (strictCheck) => + z + .object({ + enable: config.enableSsl(strictCheck), + force: config.sslForce(strictCheck), + port: config.sslPort(strictCheck), + certPath: config.sslCertPath(false) + }) + .partial(); + +// Schema for the server section of options +const ServerSchema = (strictCheck) => + z.object({ + enable: config.enableServer(strictCheck).optional(), + host: config.host(strictCheck).optional(), + port: config.port(strictCheck).optional(), + benchmarking: config.serverBenchmarking(strictCheck).optional(), + proxy: ProxySchema(strictCheck).optional(), + rateLimiting: RateLimitingSchema(strictCheck).optional(), + ssl: SslSchema(strictCheck).optional() + }); + +// Schema for the pool section of options +const PoolSchema = (strictCheck) => + z + .object({ + minWorkers: config.minWorkers(strictCheck), + maxWorkers: config.maxWorkers(strictCheck), + workLimit: config.workLimit(strictCheck), + acquireTimeout: config.acquireTimeout(strictCheck), + createTimeout: config.createTimeout(strictCheck), + destroyTimeout: config.destroyTimeout(strictCheck), + idleTimeout: config.idleTimeout(strictCheck), + createRetryInterval: config.createRetryInterval(strictCheck), + reaperInterval: config.reaperInterval(strictCheck), + benchmarking: config.poolBenchmarking(strictCheck) + }) + .partial(); + +// Schema for the logging section of options +const LoggingSchema = (strictCheck) => + z + .object({ + level: config.logLevel(strictCheck), + file: config.logFile(strictCheck), + dest: config.logDest(strictCheck), + toConsole: config.logToConsole(strictCheck), + toFile: config.logToFile(strictCheck) + }) + .partial(); + +// Schema for the ui section of options +const UiSchema = (strictCheck) => + z + .object({ + enable: config.enableUi(strictCheck), + route: config.uiRoute(strictCheck) + }) + .partial(); + +// Schema for the other section of options +const OtherSchema = (strictCheck) => + z + .object({ + nodeEnv: config.nodeEnv(strictCheck), + listenToProcessExits: config.listenToProcessExits(strictCheck), + noLogo: config.noLogo(strictCheck), + hardResetPage: config.hardResetPage(strictCheck), + browserShellMode: config.browserShellMode(strictCheck) + }) + .partial(); + +// Schema for the debug section of options +const DebugSchema = (strictCheck) => + z + .object({ + enable: config.enableDebug(strictCheck), + headless: config.headless(strictCheck), + devtools: config.devtools(strictCheck), + listenToConsole: config.listenToConsole(strictCheck), + dumpio: config.dumpio(strictCheck), + slowMo: config.slowMo(strictCheck), + debuggingPort: config.debuggingPort(strictCheck) + }) + .partial(); + +// Schema for the payload section of options +const PayloadSchema = () => + z + .object({ + requestId: config.requestId() + }) + .partial(); + +// Strict schema for the config +export const StrictConfigSchema = z.object({ + puppeteer: PuppeteerSchema(true), + highcharts: HighchartsSchema(true), + export: ExportSchema(true), + customLogic: CustomLogicSchema(true), + server: ServerSchema(true), + pool: PoolSchema(true), + logging: LoggingSchema(true), + ui: UiSchema(true), + other: OtherSchema(true), + debug: DebugSchema(true), + payload: PayloadSchema() +}); + +// Loose schema for the config +export const LooseConfigSchema = z.object({ + puppeteer: PuppeteerSchema(false), + highcharts: HighchartsSchema(false), + export: ExportSchema(false), + customLogic: CustomLogicSchema(false), + server: ServerSchema(false), + pool: PoolSchema(false), + logging: LoggingSchema(false), + ui: UiSchema(false), + other: OtherSchema(false), + debug: DebugSchema(false), + payload: PayloadSchema() +}); + +// Schema for the environment variables config +export const EnvSchema = z.object({ + // puppeteer + PUPPETEER_ARGS: config.args(false), + + // highcharts + HIGHCHARTS_VERSION: config.version(false), + HIGHCHARTS_CDN_URL: config.cdnUrl(false), + HIGHCHARTS_FORCE_FETCH: config.forceFetch(false), + HIGHCHARTS_CACHE_PATH: config.cachePath(false), + HIGHCHARTS_ADMIN_TOKEN: config.adminToken(false), + HIGHCHARTS_CORE_SCRIPTS: config.coreScripts(false), + HIGHCHARTS_MODULE_SCRIPTS: config.moduleScripts(false), + HIGHCHARTS_INDICATOR_SCRIPTS: config.indicatorScripts(false), + HIGHCHARTS_CUSTOM_SCRIPTS: config.customScripts(false), + + // export + EXPORT_INFILE: config.infile(false), + EXPORT_INSTR: config.instr(), + EXPORT_OPTIONS: config.options(), + EXPORT_SVG: config.svg(), + EXPORT_TYPE: config.type(false), + EXPORT_CONSTR: config.constr(false), + EXPORT_OUTFILE: config.outfile(false), + EXPORT_B64: config.b64(false), + EXPORT_NO_DOWNLOAD: config.noDownload(false), + EXPORT_HEIGHT: config.height(false), + EXPORT_WIDTH: config.width(false), + EXPORT_SCALE: config.scale(false), + EXPORT_DEFAULT_HEIGHT: config.defaultHeight(false), + EXPORT_DEFAULT_WIDTH: config.defaultWidth(false), + EXPORT_DEFAULT_SCALE: config.defaultScale(false), + EXPORT_GLOBAL_OPTIONS: config.globalOptions(), + EXPORT_THEME_OPTIONS: config.themeOptions(), + EXPORT_BATCH: config.batch(false), + EXPORT_RASTERIZATION_TIMEOUT: config.rasterizationTimeout(false), + + // custom + CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: config.allowCodeExecution(false), + CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: config.allowFileResources(false), + CUSTOM_LOGIC_CUSTOM_CODE: config.customCode(false), + CUSTOM_LOGIC_CALLBACK: config.callback(false), + CUSTOM_LOGIC_RESOURCES: config.resources(false), + CUSTOM_LOGIC_LOAD_CONFIG: config.loadConfig(false), + CUSTOM_LOGIC_CREATE_CONFIG: config.createConfig(false), + + // server + SERVER_ENABLE: config.enableServer(false), + SERVER_HOST: config.host(false), + SERVER_PORT: config.port(false), + SERVER_BENCHMARKING: config.serverBenchmarking(false), + + // server proxy + SERVER_PROXY_HOST: config.proxyHost(false), + SERVER_PROXY_PORT: config.proxyPort(false), + SERVER_PROXY_TIMEOUT: config.proxyTimeout(false), + + // server rate limiting + SERVER_RATE_LIMITING_ENABLE: config.enableRateLimiting(false), + SERVER_RATE_LIMITING_MAX_REQUESTS: config.maxRequests(false), + SERVER_RATE_LIMITING_WINDOW: config.window(false), + SERVER_RATE_LIMITING_DELAY: config.delay(false), + SERVER_RATE_LIMITING_TRUST_PROXY: config.trustProxy(false), + SERVER_RATE_LIMITING_SKIP_KEY: config.skipKey(false), + SERVER_RATE_LIMITING_SKIP_TOKEN: config.skipToken(false), + + // server ssl + SERVER_SSL_ENABLE: config.enableSsl(false), + SERVER_SSL_FORCE: config.sslForce(false), + SERVER_SSL_PORT: config.sslPort(false), + SERVER_SSL_CERT_PATH: config.sslCertPath(false), + + // pool + POOL_MIN_WORKERS: config.minWorkers(false), + POOL_MAX_WORKERS: config.maxWorkers(false), + POOL_WORK_LIMIT: config.workLimit(false), + POOL_ACQUIRE_TIMEOUT: config.acquireTimeout(false), + POOL_CREATE_TIMEOUT: config.createTimeout(false), + POOL_DESTROY_TIMEOUT: config.destroyTimeout(false), + POOL_IDLE_TIMEOUT: config.idleTimeout(false), + POOL_CREATE_RETRY_INTERVAL: config.createRetryInterval(false), + POOL_REAPER_INTERVAL: config.reaperInterval(false), + POOL_BENCHMARKING: config.poolBenchmarking(false), + + // logging + LOGGING_LEVEL: config.logLevel(false), + LOGGING_FILE: config.logFile(false), + LOGGING_DEST: config.logDest(false), + LOGGING_TO_CONSOLE: config.logToConsole(false), + LOGGING_TO_FILE: config.logToFile(false), + + // ui + UI_ENABLE: config.enableUi(false), + UI_ROUTE: config.uiRoute(false), + + // other + OTHER_NODE_ENV: config.nodeEnv(false), + OTHER_LISTEN_TO_PROCESS_EXITS: config.listenToProcessExits(false), + OTHER_NO_LOGO: config.noLogo(false), + OTHER_HARD_RESET_PAGE: config.hardResetPage(false), + OTHER_BROWSER_SHELL_MODE: config.browserShellMode(false), + + // debugger + DEBUG_ENABLE: config.enableDebug(false), + DEBUG_HEADLESS: config.headless(false), + DEBUG_DEVTOOLS: config.devtools(false), + DEBUG_LISTEN_TO_CONSOLE: config.listenToConsole(false), + DEBUG_DUMPIO: config.dumpio(false), + DEBUG_SLOW_MO: config.slowMo(false), + DEBUG_DEBUGGING_PORT: config.debuggingPort(false) +}); + +/** + * Validates the environment variables options using the EnvSchema. + * + * @param {Object} process.env - The configuration options from environment + * variables file to validate. + * + * @returns {Object} The parsed and validated environment variables. + */ +export const envs = EnvSchema.partial().parse(process.env); + +/** + * Validates the configuration options using the `StrictConfigSchema`. + * + * @function strictValidate + * + * @param {Object} configOptions - The configuration options to validate. + * + * @returns {Object} The parsed and validated configuration options. + */ +export function strictValidate(configOptions) { + return StrictConfigSchema.partial().parse(configOptions); +} + +/** + * Validates the configuration options using the `LooseConfigSchema`. + * + * @function looseValidate + * + * @param {Object} configOptions - The configuration options to validate. + * + * @returns {Object} The parsed and validated configuration options. + */ +export function looseValidate(configOptions) { + return LooseConfigSchema.partial().parse(configOptions); +} + +/** + * Validates a provided option using the specific validator from the config + * object. + * + * @function validateOption + * + * @param {string} name - The name of an option to validate. + * @param {any} option - The option to validate. + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {any} The parsed and validated option value. + */ +export function validateOption(name, option, strictCheck) { + return config[name](strictCheck).parse(option); +} + +/** + * Custom error mapping function for Zod schema validation. + * + * This function customizes the error messages produced by Zod schema + * validation, providing more specific and user-friendly feedback based on the + * issue type and context. + * + * The function modifies the error messages as follows: + * + * - For missing required values (undefined), it returns a message indicating + * that no value was provided for the specific property. + * + * - For custom validation errors, if a custom error message is provided in the + * issue parameters, it includes this message along with the invalid data + * received. + * + * - For all other errors, it appends property-specific information to the + * default error message provided by Zod. + * + * @function _customErrorMap + * + * @param {z.ZodIssue} issue - The issue object representing the validation + * error. + * @param {Object} context - The context object providing additional information + * about the validation error. + * + * @returns {Object} An object containing the customized error message. + */ +function _customErrorMap(issue, context) { + // Get the chain of properties which error directly refers to + const propertyName = issue.path.join('.'); + + // Create the first part of the message about the property information + const propertyInfo = `Invalid value for the ${propertyName}`; + + // Modified message for the invalid type + if (issue.code === z.ZodIssueCode.invalid_type) { + // Modified message for the required values + if (issue.received === z.ZodParsedType.undefined) { + return { + message: `${propertyInfo} - No value was provided.` + }; + } + + // Modified message for the specific invalid type when values exist + return { + message: `${propertyInfo} - Invalid type. ${context.defaultError}.` + }; + } + + // Modified message for the custom validation + if (issue.code === z.ZodIssueCode.custom) { + // If the custom message for error exist, include it + if (issue.params?.errorMessage) { + return { + message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.` + }; + } + } + + // Modified message for the invalid union error + if (issue.code === z.ZodIssueCode.invalid_union) { + // Create the first part of the message about the multiple errors + let message = `Multiple errors occurred for the ${propertyName}:\n`; + + // Cycle through all errors and create a correct message + issue.unionErrors.forEach((value) => { + const index = value.issues[0].message.indexOf('-'); + message += + index !== -1 + ? `${value.issues[0].message}\n`.substring(index) + : `${value.issues[0].message}\n`; + }); + + // Return the final message for the invalid union error + return { + message + }; + } + + // Return the default error message, extended by the info about the property + return { + message: `${propertyInfo} - ${context.defaultError}.` + }; +} + +export default { + StrictConfigSchema, + LooseConfigSchema, + EnvSchema, + envs, + strictValidate, + looseValidate, + validateOption +}; From 8aa49a73e1c896403a6fc2714b2943ac1d4895f9 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 10 Dec 2024 22:18:37 +0100 Subject: [PATCH 02/19] Added a new function to API called logZodIssues to log zod errors appropriately. --- README.md | 6 ++++++ lib/index.js | 2 ++ lib/logger.js | 23 +++++++++++++++++++++++ 3 files changed, 31 insertions(+) diff --git a/README.md b/README.md index 07686bbe..ded6f11a 100644 --- a/README.md +++ b/README.md @@ -802,6 +802,12 @@ This package supports both CommonJS and ES modules. - `@param {Error} error` - The error object. - `@param {string} customMessage` - An optional custom message to be logged along with the error. +- `function logZodIssues(newLevel, issues = [], customMessage)`: Logs an error message about Zod issues with the validation. Optionally, a custom message can be provided. + + - `@param {number} newLevel` - The log level. + - `@param {Error[]} issues` - The array of Zod issues. + - `@param {string} customMessage` - An optional custom message to be logged along with the error. + - `function setLogLevel(newLevel)`: Sets the log level to the specified value. Log levels are (0 = no logging, 1 = error, 2 = warning, 3 = notice, 4 = verbose or 5 = benchmark). - `@param {number} newLevel` - The new log level to be set. diff --git a/lib/index.js b/lib/index.js index 24daefc8..dfa1ee78 100644 --- a/lib/index.js +++ b/lib/index.js @@ -32,6 +32,7 @@ import { getOptions, setOptions } from './config.js'; import { log, logWithStack, + logZodIssues, initLogging, setLogLevel, enableFileLogging @@ -137,6 +138,7 @@ export default { // Logs log, logWithStack, + logZodIssues, setLogLevel, enableFileLogging, diff --git a/lib/logger.js b/lib/logger.js index 82f0be67..7524f0bc 100644 --- a/lib/logger.js +++ b/lib/logger.js @@ -179,6 +179,28 @@ export function logWithStack(newLevel, error, customMessage) { } } +/** + * Logs an error message about Zod issues with the validation. Optionally, + * a custom message can be provided. + * + * @function logZodIssues + * + * @param {number} newLevel - The log level. + * @param {Error[]} issues - The array of Zod issues. + * @param {string} customMessage - An optional custom message to be logged + * along with the error. + */ +export function logZodIssues(newLevel, issues = [], customMessage) { + logWithStack( + newLevel, + null, + [ + `${customMessage} - the following Zod issues occured:`, + ...issues.map((issue) => `- ${issue.message}`) + ].join('\n') + ); +} + /** * Sets the log level to the specified value. Log levels are (0 = no logging, * 1 = error, 2 = warning, 3 = notice, 4 = verbose or 5 = benchmark). @@ -251,6 +273,7 @@ export default { initLogging, log, logWithStack, + logZodIssues, setLogLevel, enableFileLogging }; From 935486e2d37ad69014a5394ec3f53af490bb46b4 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 10 Dec 2024 22:19:01 +0100 Subject: [PATCH 03/19] Validate options. --- lib/chart.js | 26 +++++++++- lib/config.js | 34 ++++++++++--- lib/errors/ValidationError.js | 33 ++++++++++++ lib/server/middlewares/validation.js | 75 +++++++++++++++------------- 4 files changed, 126 insertions(+), 42 deletions(-) create mode 100644 lib/errors/ValidationError.js diff --git a/lib/chart.js b/lib/chart.js index 8c1bfe61..6365e4bc 100644 --- a/lib/chart.js +++ b/lib/chart.js @@ -22,7 +22,7 @@ See LICENSE file in root for details. import { readFileSync, writeFileSync } from 'fs'; import { getOptions } from './config.js'; -import { log, logWithStack } from './logger.js'; +import { log, logWithStack, logZodIssues } from './logger.js'; import { killPool, postWork, getPoolStats } from './pool.js'; import { sanitize } from './sanitize.js'; import { @@ -32,6 +32,7 @@ import { roundNumber, wrapAround } from './utils.js'; +import { strictValidate, validateOption } from './validation.js'; import ExportError from './errors/ExportError.js'; @@ -98,7 +99,20 @@ export async function startExport(options = getOptions(), endCallback) { log(4, '[chart] Attempting to export from a file input.'); // Try to read the file to get the string representation - exportOptions.instr = readFileSync(exportOptions.infile, 'utf8'); + try { + exportOptions.instr = validateOption( + 'instr', + readFileSync(exportOptions.infile, 'utf8'), + false + ); + } catch (error) { + logZodIssues( + 1, + error.issues, + '[config] The `infile` option validation error' + ); + throw error; + } // Export from a file options return _exportAsString(exportOptions.instr, options, endCallback); @@ -457,6 +471,14 @@ async function _prepareExport(options, endCallback, json, svg) { ..._findChartSize(exportOptions) }; + // The last strict validation of options right before exporting process + try { + // Validate final options + options = strictValidate(options); + } catch (error) { + logZodIssues(1, error.issues, '[config] Final options validation error'); + } + // Post the work to the pool try { const result = await postWork(exportOptions.strInj || json || svg, options); diff --git a/lib/config.js b/lib/config.js index 27c4ebd0..66e30a3b 100644 --- a/lib/config.js +++ b/lib/config.js @@ -22,9 +22,9 @@ See LICENSE file in root for details. import { readFileSync } from 'fs'; -import { log, logWithStack } from './logger.js'; -import { envs } from './envs.js'; +import { log, logWithStack, logZodIssues } from './logger.js'; import { deepCopy } from './utils.js'; +import { envs, looseValidate, strictValidate } from './validation.js'; import { defaultConfig, nestedArgs } from './schemas/config.js'; // Sets the global options with initial values from the default config @@ -77,14 +77,36 @@ export function setOptions( // Only for the CLI usage if (cliArgs.length) { - // Get options from the custom JSON loaded via the `loadConfig` - configOptions = _loadConfigFile(cliArgs); + try { + // Validate options from the custom JSON loaded via the `loadConfig` + configOptions = strictValidate(_loadConfigFile(cliArgs)); + } catch (error) { + logZodIssues( + 1, + error.issues, + '[config] Custom JSON options validation error' + ); + } + } + + // Apply custom options if there are any + if (customOptions && Object.keys(customOptions).length !== 0) { + try { + // Validate custom options provided by the user + customOptions = strictValidate(customOptions); + } catch (error) { + logZodIssues(1, error.issues, '[config] Custom options validation error'); + } } // Only for the CLI usage if (cliArgs.length) { - // Get options from the CLI - cliOptions = _pairArgumentValue(nestedArgs, cliArgs); + try { + // Validate options from the CLI + cliOptions = looseValidate(_pairArgumentValue(nestedArgs, cliArgs)); + } catch (error) { + logZodIssues(1, error.issues, '[config] CLI options validation error'); + } } // Get the reference to the global options object or a copy of the object diff --git a/lib/errors/ValidationError.js b/lib/errors/ValidationError.js new file mode 100644 index 00000000..7418a4f3 --- /dev/null +++ b/lib/errors/ValidationError.js @@ -0,0 +1,33 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +import HttpError from './HttpError.js'; + +/** + * The `ValidationError` error class that extends `HttpError`. Used to handle + * errors related to validation of provided options. + */ +class ValidationError extends HttpError { + /** + * Creates an instance of `ValidationError`. + */ + constructor() { + super( + 'The provided options are not correct. Please check if your data is of the correct types.', + 400 + ); + } +} + +export default ValidationError; diff --git a/lib/server/middlewares/validation.js b/lib/server/middlewares/validation.js index 04dce82e..82aae968 100644 --- a/lib/server/middlewares/validation.js +++ b/lib/server/middlewares/validation.js @@ -26,7 +26,7 @@ See LICENSE file in root for details. import { v4 as uuid } from 'uuid'; import { getAllowCodeExecution } from '../../chart.js'; -import { log } from '../../logger.js'; +import { log, logZodIssues } from '../../logger.js'; import { fixConstr, fixType, @@ -34,11 +34,13 @@ import { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js'; +import { looseValidate } from '../../validation.js'; import HttpError from '../../errors/HttpError.js'; import NoCorrectBodyError from '../../errors/NoCorrectBodyError.js'; import NoCorrectChartDataError from '../../errors/NoCorrectChartDataError.js'; import PrivateRangeUrlError from '../../errors/PrivateRangeUrlError.js'; +import ValidationError from '../../errors/ValidationError.js'; /** * Middleware for validating the content-type header. @@ -135,39 +137,44 @@ function requestBodyMiddleware(request, _response, next) { throw PrivateRangeUrlError(); } - // Get options from the body and store parsed structure in the request - request.validatedOptions = { - export: { - instr, - svg: body.svg, - outfile: - body.outfile || - `${request.params.filename || 'chart'}.${fixType(body.type)}`, - type: fixType(body.type), - constr: fixConstr(body.constr), - b64: body.b64, - noDownload: body.noDownload, - height: body.height, - width: body.width, - scale: body.scale, - globalOptions: isCorrectJSON( - body.globalOptions, - true, - allowCodeExecution - ), - themeOptions: isCorrectJSON(body.themeOptions, true, allowCodeExecution) - }, - customLogic: { - allowCodeExecution, - allowFileResources: false, - customCode: body.customCode, - callback: body.callback, - resources: isCorrectJSON(body.resources, true, allowCodeExecution) - }, - payload: { - requestId - } - }; + try { + // Validate options from the body and store parsed structure in the request + request.validatedOptions = looseValidate({ + export: { + instr, + svg: body.svg, + outfile: + body.outfile || + `${request.params.filename || 'chart'}.${fixType(body.type)}`, + type: fixType(body.type), + constr: fixConstr(body.constr), + b64: body.b64, + noDownload: body.noDownload, + height: body.height, + width: body.width, + scale: body.scale, + globalOptions: isCorrectJSON( + body.globalOptions, + true, + allowCodeExecution + ), + themeOptions: isCorrectJSON(body.themeOptions, true, allowCodeExecution) + }, + customLogic: { + allowCodeExecution, + allowFileResources: false, + customCode: body.customCode, + callback: body.callback, + resources: isCorrectJSON(body.resources, true, allowCodeExecution) + }, + payload: { + requestId + } + }); + } catch (error) { + logZodIssues(1, error.issues, '[config] Request options validation error'); + throw new ValidationError(); + } return next(); } From 4192bae6c78fc2d0f2b43f501df453bbe6eeaceb Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 10 Dec 2024 22:19:16 +0100 Subject: [PATCH 04/19] Added exhaustive testing of options validations. --- tests/unit/envs.test.js | 76 - tests/unit/validation/cli.test.js | 667 +++++++ tests/unit/validation/config.test.js | 678 +++++++ tests/unit/validation/envs.test.js | 341 ++++ tests/unit/validation/shared.js | 2565 ++++++++++++++++++++++++++ tests/utils/testUtils.js | 129 ++ 6 files changed, 4380 insertions(+), 76 deletions(-) delete mode 100644 tests/unit/envs.test.js create mode 100644 tests/unit/validation/cli.test.js create mode 100644 tests/unit/validation/config.test.js create mode 100644 tests/unit/validation/envs.test.js create mode 100644 tests/unit/validation/shared.js create mode 100644 tests/utils/testUtils.js diff --git a/tests/unit/envs.test.js b/tests/unit/envs.test.js deleted file mode 100644 index bf13f9a8..00000000 --- a/tests/unit/envs.test.js +++ /dev/null @@ -1,76 +0,0 @@ -/******************************************************************************* - -Highcharts Export Server - -Copyright (c) 2016-2024, Highsoft - -Licenced under the MIT licence. - -Additionally a valid Highcharts license is required for use. - -See LICENSE file in root for details. - -*******************************************************************************/ - -import { Config } from '../../lib/envs.js'; - -describe('Environment variables should be correctly parsed', () => { - test('HIGHCHARTS_VERSION accepts latests and not unrelated strings', () => { - const env = { HIGHCHARTS_VERSION: 'string-other-than-latest' }; - expect(() => Config.partial().parse(env)).toThrow(); - - env.HIGHCHARTS_VERSION = 'latest'; - expect(Config.partial().parse(env).HIGHCHARTS_VERSION).toEqual('latest'); - }); - - test('HIGHCHARTS_VERSION accepts proper version strings like XX.YY.ZZ', () => { - const env = { HIGHCHARTS_VERSION: '11' }; - expect(Config.partial().parse(env).HIGHCHARTS_VERSION).toEqual('11'); - - env.HIGHCHARTS_VERSION = '11.0.0'; - expect(Config.partial().parse(env).HIGHCHARTS_VERSION).toEqual('11.0.0'); - - env.HIGHCHARTS_VERSION = '9.1'; - expect(Config.partial().parse(env).HIGHCHARTS_VERSION).toEqual('9.1'); - - env.HIGHCHARTS_VERSION = '11a.2.0'; - expect(() => Config.partial().parse(env)).toThrow(); - }); - - test('HIGHCHARTS_CDN_URL should start with http:// or https://', () => { - const env = { HIGHCHARTS_CDN_URL: 'http://example.com' }; - expect(Config.partial().parse(env).HIGHCHARTS_CDN_URL).toEqual( - 'http://example.com' - ); - - env.HIGHCHARTS_CDN_URL = 'https://example.com'; - expect(Config.partial().parse(env).HIGHCHARTS_CDN_URL).toEqual( - 'https://example.com' - ); - - env.HIGHCHARTS_CDN_URL = 'example.com'; - expect(() => Config.partial().parse(env)).toThrow(); - }); - - test('CORE, MODULE, INDICATOR scripts should be arrays', () => { - const env = { - HIGHCHARTS_CORE_SCRIPTS: 'core1, core2, highcharts', - HIGHCHARTS_MODULE_SCRIPTS: 'module1, map, module2', - HIGHCHARTS_INDICATOR_SCRIPTS: 'indicators-all, indicator1, indicator2' - }; - - const parsed = Config.partial().parse(env); - - expect(parsed.HIGHCHARTS_CORE_SCRIPTS).toEqual(['highcharts']); - expect(parsed.HIGHCHARTS_MODULE_SCRIPTS).toEqual(['map']); - expect(parsed.HIGHCHARTS_INDICATOR_SCRIPTS).toEqual(['indicators-all']); - }); - - test('HIGHCHARTS_FORCE_FETCH should be a boolean', () => { - const env = { HIGHCHARTS_FORCE_FETCH: 'true' }; - expect(Config.partial().parse(env).HIGHCHARTS_FORCE_FETCH).toEqual(true); - - env.HIGHCHARTS_FORCE_FETCH = 'false'; - expect(Config.partial().parse(env).HIGHCHARTS_FORCE_FETCH).toEqual(false); - }); -}); diff --git a/tests/unit/validation/cli.test.js b/tests/unit/validation/cli.test.js new file mode 100644 index 00000000..df90c4ff --- /dev/null +++ b/tests/unit/validation/cli.test.js @@ -0,0 +1,667 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +import { describe } from '@jest/globals'; + +import { configTests } from './shared.js'; +import { LooseConfigSchema } from '../../../lib/validation.js'; + +describe('CLI options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.partial(), false); + + // puppeteer + tests.puppeteer('puppeteer', { + args: [ + '--allow-running-insecure-content', + '--ash-no-nudges', + '--autoplay-policy=user-gesture-required', + '--block-new-web-contents', + '--disable-accelerated-2d-canvas', + '--disable-background-networking', + '--disable-background-timer-throttling', + '--disable-backgrounding-occluded-windows', + '--disable-breakpad', + '--disable-checker-imaging', + '--disable-client-side-phishing-detection', + '--disable-component-extensions-with-background-pages', + '--disable-component-update', + '--disable-default-apps', + '--disable-dev-shm-usage', + '--disable-domain-reliability', + '--disable-extensions', + '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP', + '--disable-hang-monitor', + '--disable-ipc-flooding-protection', + '--disable-logging', + '--disable-notifications', + '--disable-offer-store-unmasked-wallet-cards', + '--disable-popup-blocking', + '--disable-print-preview', + '--disable-prompt-on-repost', + '--disable-renderer-backgrounding', + '--disable-search-engine-choice-screen', + '--disable-session-crashed-bubble', + '--disable-setuid-sandbox', + '--disable-site-isolation-trials', + '--disable-speech-api', + '--disable-sync', + '--enable-unsafe-webgpu', + '--hide-crash-restore-bubble', + '--hide-scrollbars', + '--metrics-recording-only', + '--mute-audio', + '--no-default-browser-check', + '--no-first-run', + '--no-pings', + '--no-sandbox', + '--no-startup-window', + '--no-zygote', + '--password-store=basic', + '--process-per-tab', + '--use-mock-keychain' + ] + }); + + // highcharts + tests.highcharts('highcharts', { + version: 'latest', + cdnUrl: 'https://code.highcharts.com', + forceFetch: false, + cachePath: '.cache', + coreScripts: ['highcharts', 'highcharts-more', 'highcharts-3d'], + moduleScripts: [ + 'stock', + 'map', + 'gantt', + 'exporting', + 'parallel-coordinates', + 'accessibility', + // 'annotations-advanced', + 'boost-canvas', + 'boost', + 'data', + 'data-tools', + 'draggable-points', + 'static-scale', + 'broken-axis', + 'heatmap', + 'tilemap', + 'tiledwebmap', + 'timeline', + 'treemap', + 'treegraph', + 'item-series', + 'drilldown', + 'histogram-bellcurve', + 'bullet', + 'funnel', + 'funnel3d', + 'geoheatmap', + 'pyramid3d', + 'networkgraph', + 'overlapping-datalabels', + 'pareto', + 'pattern-fill', + 'pictorial', + 'price-indicator', + 'sankey', + 'arc-diagram', + 'dependency-wheel', + 'series-label', + 'series-on-point', + 'solid-gauge', + 'sonification', + // 'stock-tools', + 'streamgraph', + 'sunburst', + 'variable-pie', + 'variwide', + 'vector', + 'venn', + 'windbarb', + 'wordcloud', + 'xrange', + 'no-data-to-display', + 'drag-panes', + 'debugger', + 'dumbbell', + 'lollipop', + 'cylinder', + 'organization', + 'dotplot', + 'marker-clusters', + 'hollowcandlestick', + 'heikinashi', + 'flowmap', + 'export-data', + 'navigator', + 'textpath' + ], + indicatorScripts: ['indicators-all'], + customScripts: [ + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js', + 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js' + ] + }); + + // export + tests.export('export', { + infile: null, + instr: null, + options: null, + svg: null, + outfile: null, + type: 'png', + constr: 'chart', + b64: false, + noDownload: false, + defaultHeight: 400, + defaultWidth: 600, + defaultScale: 1, + height: null, + width: null, + scale: null, + globalOptions: null, + themeOptions: null, + batch: null, + rasterizationTimeout: 1500 + }); + + // customLogic + tests.customLogic('customLogic', { + allowCodeExecution: false, + allowFileResources: false, + customCode: null, + callback: null, + resources: null, + loadConfig: null, + createConfig: null + }); + + // server + tests.server('server', { + enable: false, + host: '0.0.0.0', + port: 7801, + benchmarking: false, + proxy: { + host: null, + port: null, + timeout: 5000 + }, + rateLimiting: { + enable: false, + maxRequests: 10, + window: 1, + delay: 0, + trustProxy: false, + skipKey: null, + skipToken: null + }, + ssl: { + enable: false, + force: false, + port: 443, + certPath: null + } + }); + + // pool + tests.pool('pool', { + minWorkers: 4, + maxWorkers: 8, + workLimit: 40, + acquireTimeout: 5000, + createTimeout: 5000, + destroyTimeout: 5000, + idleTimeout: 30000, + createRetryInterval: 200, + reaperInterval: 1000, + benchmarking: false + }); + + // logging + tests.logging('logging', { + level: 4, + file: 'highcharts-export-server.log', + dest: 'log', + toConsole: true, + toFile: true + }); + + // ui + tests.ui('ui', { + enable: false, + route: '/' + }); + + // other + tests.other('other', { + nodeEnv: 'production', + listenToProcessExits: true, + noLogo: false, + hardResetPage: false, + browserShellMode: true + }); + + // debug + tests.debug('debug', { + enable: false, + headless: true, + devtools: false, + listenToConsole: false, + dumpio: false, + slowMo: 0, + debuggingPort: 9222 + }); + + // payload + tests.payload('payload', { + requestId: 'd4faa416-0e85-433a-9f84-e735567d8fa5' + }); +}); + +describe('Puppeteer configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.puppeteer, false); + + // puppeteer.args + tests.puppeteerArgs( + 'args', + '--disable-sync; --enable-unsafe-webgpu; --hide-crash-restore-bubble; --hide-scrollbars; --metrics-recording-only', + [ + '--disable-sync', + '--enable-unsafe-webgpu', + '--hide-crash-restore-bubble', + '--hide-scrollbars', + '--metrics-recording-only' + ] + ); +}); + +describe('Highcharts configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.highcharts, false); + + // highcharts.version + tests.highchartsVersion('version'); + + // highcharts.cdnUrl + tests.highchartsCdnUrl( + 'cdnUrl', + ['http://example.com', 'https://example.com'], + ['http:a.com', 'http:/b.com', 'https:c.com', 'https:/d.com'] + ); + + // highcharts.forceFetch + tests.highchartsForceFetch('forceFetch'); + + // highcharts.cachePath + tests.highchartsCachePath('cachePath'); + + // highcharts.coreScripts + tests.highchartsCoreScripts( + 'coreScripts', + 'highcharts, highcharts-more, text1, highcharts-3d, text2', + ['highcharts', 'highcharts-more', 'highcharts-3d'] + ); + + // highcharts.moduleScripts + tests.highchartsModuleScripts( + 'moduleScripts', + 'data, text1, data-tools, text2', + ['data', 'data-tools'] + ); + + // highcharts.indicatorScripts + tests.highchartsIndicatorScripts( + 'indicatorScripts', + 'text1, indicators-all, text2', + ['indicators-all'] + ); + + // highcharts.customScripts + tests.highchartsCustomScripts( + 'customScripts', + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js, text1, https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js, text2', + [ + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js', + 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js' + ] + ); +}); + +describe('Export configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.export, false); + + // export.infile + tests.exportInfile('infile'); + + // export.instr + tests.exportInstr('instr'); + + // export.options + tests.exportOptions('options'); + + // export.svg + tests.exportSvg('svg'); + + // export.outfile + tests.exportOutfile('outfile'); + + // export.type + tests.exportType( + 'type', + ['jpeg', 'jpg', 'png', 'pdf', 'svg'], + ['json', 'txt'] + ); + + // export.constr + tests.exportConstr( + 'constr', + ['chart', 'stockChart', 'mapChart', 'ganttChart'], + ['stock', 'map', 'gantt'] + ); + + // export.b64 + tests.exportB64('b64'); + + // export.noDownload + tests.exportNoDownload('noDownload'); + + // export.defaultHeight + tests.exportDefaultHeight('defaultHeight'); + + // export.defaultWidth + tests.exportDefaultWidth('defaultWidth'); + + // export.defaultScale + tests.exportDefaultScale('defaultScale'); + + // export.height + tests.exportHeight('height'); + + // export.width + tests.exportWidth('width'); + + // export.scale + tests.exportScale('scale'); + + // export.globalOptions + tests.exportGlobalOptions('globalOptions'); + + // export.themeOptions + tests.exportThemeOptions('themeOptions'); + + // export.batch + tests.exportBatch('batch'); + + // export.rasterizationTimeout + tests.exportRasterizationTimeout('rasterizationTimeout'); +}); + +describe('Custom Logic configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.customLogic, false); + + // customLogic.allowCodeExecution + tests.customLogicAllowCodeExecution('allowCodeExecution'); + + // customLogic.allowFileResources + tests.customLogicAllowFileResources('allowFileResources'); + + // customLogic.customCode + tests.customLogicCustomCode('customCode'); + + // customLogic.callback + tests.customLogicCallback('callback'); + + // customLogic.resources + tests.customLogicResources('resources'); + + // customLogic.loadConfig + tests.customLogicLoadConfig('loadConfig'); + + // customLogic.createConfig + tests.customLogicCreateConfig('createConfig'); +}); + +describe('Server configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.server, false); + + // server.enable + tests.serverEnable('enable'); + + // server.host + tests.serverHost('host'); + + // server.port + tests.serverPort('port'); + + // server.benchmarking + tests.serverBenchmarking('benchmarking'); + + // server.proxy + tests.serverProxy('proxy', { + host: null, + port: null, + timeout: 5000 + }); + + // server.rateLimiting + tests.serverRateLimiting('rateLimiting', { + enable: false, + maxRequests: 10, + window: 1, + delay: 0, + trustProxy: false, + skipKey: null, + skipToken: null + }); + + // server.ssl + tests.serverSsl('ssl', { + enable: false, + force: false, + port: 443, + certPath: null + }); +}); + +describe('Server Proxy configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.server.shape.proxy, false); + + // server.proxy.host + tests.serverProxyHost('host'); + + // server.proxy.port + tests.serverProxyPort('port'); + + // server.proxy.timeout + tests.serverProxyTimeout('timeout'); +}); + +describe('Server Rate Limiting configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests( + LooseConfigSchema.shape.server.shape.rateLimiting, + false + ); + + // server.rateLimiting.enable + tests.serverRateLimitingEnable('enable'); + + // server.rateLimiting.maxRequests + tests.serverRateLimitingMaxRequests('maxRequests'); + + // server.rateLimiting.window + tests.serverRateLimitingWindow('window'); + + // server.rateLimiting.delay + tests.serverRateLimitingDelay('delay'); + + // server.rateLimiting.trustProxy + tests.serverRateLimitingTrustProxy('trustProxy'); + + // server.rateLimiting.skipKey + tests.serverRateLimitingSkipKey('skipKey'); + + // server.rateLimiting.skipToken + tests.serverRateLimitingSkipToken('skipToken'); +}); + +describe('Server SSL configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.server.shape.ssl, false); + + // server.ssl.enable + tests.serverSslEnable('enable'); + + // server.ssl.force + tests.serverSslForce('force'); + + // server.ssl.port + tests.serverSslPort('port'); + + // server.ssl.certPath + tests.serverSslCertPath('certPath'); +}); + +describe('Pool configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.pool, false); + + // pool.minWorkers + tests.poolMinWorkers('minWorkers'); + + // pool.maxWorkers + tests.poolMaxWorkers('maxWorkers'); + + // pool.workLimit + tests.poolWorkLimit('workLimit'); + + // pool.acquireTimeout + tests.poolAcquireTimeout('acquireTimeout'); + + // pool.createTimeout + tests.poolCreateTimeout('createTimeout'); + + // pool.destroyTimeout + tests.poolDestroyTimeout('destroyTimeout'); + + // pool.idleTimeout + tests.poolIdleTimeout('idleTimeout'); + + // pool.createRetryInterval + tests.poolCreateRetryInterval('createRetryInterval'); + + // pool.reaperInterval + tests.poolReaperInterval('reaperInterval'); + + // pool.benchmarking + tests.poolBenchmarking('benchmarking'); +}); + +describe('Logging configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.logging, false); + + // logging.level + tests.loggingLevel('level'); + + // logging.file + tests.loggingFile('file'); + + // logging.dest + tests.loggingDest('dest'); + + // logging.toConsole + tests.loggingToConsole('toConsole'); + + // logging.toFile + tests.loggingToFile('toFile'); +}); + +describe('UI configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.ui, false); + + // ui.enable + tests.uiEnable('enable'); + + // ui.route + tests.uiRoute('route', ['/', '/ui'], ['ui', 'example/ui/']); +}); + +describe('Other configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.other, false); + + // other.nodeEnv + tests.otherNodeEnv( + 'nodeEnv', + ['development', 'production', 'test'], + ['dev-env', 'prod-env', 'test-env'] + ); + + // other.listenToProcessExits + tests.otherListenToProcessExits('listenToProcessExits'); + + // other.noLogo + tests.otherNoLogo('noLogo'); + + // other.hardResetPage + tests.otherHardResetPage('hardResetPage'); + + // other.browserShellMode + tests.otherBrowserShellMode('browserShellMode'); +}); + +describe('Debug configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.debug, false); + + // debug.enable + tests.debugEnable('enable'); + + // debug.headless + tests.debugHeadless('headless'); + + // debug.devtools + tests.debugDevtools('devtools'); + + // debug.listenToConsole + tests.debugListenToConsole('listenToConsole'); + + // debug.dumpio + tests.debugDumpio('dumpio'); + + // debug.slowMo + tests.debugSlowMo('slowMo'); + + // debug.debuggingPort + tests.debugDebuggingPort('debuggingPort'); +}); + +describe('Payload configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(LooseConfigSchema.shape.payload, false); + + // payload.requestId + tests.payloadRequestId('requestId'); +}); diff --git a/tests/unit/validation/config.test.js b/tests/unit/validation/config.test.js new file mode 100644 index 00000000..72890cd5 --- /dev/null +++ b/tests/unit/validation/config.test.js @@ -0,0 +1,678 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +import { describe } from '@jest/globals'; + +import { configTests } from './shared.js'; +import { StrictConfigSchema } from '../../../lib/validation.js'; + +describe('Configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.partial(), true); + + // puppeteer + tests.puppeteer('puppeteer', { + args: [ + '--allow-running-insecure-content', + '--ash-no-nudges', + '--autoplay-policy=user-gesture-required', + '--block-new-web-contents', + '--disable-accelerated-2d-canvas', + '--disable-background-networking', + '--disable-background-timer-throttling', + '--disable-backgrounding-occluded-windows', + '--disable-breakpad', + '--disable-checker-imaging', + '--disable-client-side-phishing-detection', + '--disable-component-extensions-with-background-pages', + '--disable-component-update', + '--disable-default-apps', + '--disable-dev-shm-usage', + '--disable-domain-reliability', + '--disable-extensions', + '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP', + '--disable-hang-monitor', + '--disable-ipc-flooding-protection', + '--disable-logging', + '--disable-notifications', + '--disable-offer-store-unmasked-wallet-cards', + '--disable-popup-blocking', + '--disable-print-preview', + '--disable-prompt-on-repost', + '--disable-renderer-backgrounding', + '--disable-search-engine-choice-screen', + '--disable-session-crashed-bubble', + '--disable-setuid-sandbox', + '--disable-site-isolation-trials', + '--disable-speech-api', + '--disable-sync', + '--enable-unsafe-webgpu', + '--hide-crash-restore-bubble', + '--hide-scrollbars', + '--metrics-recording-only', + '--mute-audio', + '--no-default-browser-check', + '--no-first-run', + '--no-pings', + '--no-sandbox', + '--no-startup-window', + '--no-zygote', + '--password-store=basic', + '--process-per-tab', + '--use-mock-keychain' + ] + }); + + // highcharts + tests.highcharts('highcharts', { + version: 'latest', + cdnUrl: 'https://code.highcharts.com', + forceFetch: false, + cachePath: '.cache', + coreScripts: ['highcharts', 'highcharts-more', 'highcharts-3d'], + moduleScripts: [ + 'stock', + 'map', + 'gantt', + 'exporting', + 'parallel-coordinates', + 'accessibility', + // 'annotations-advanced', + 'boost-canvas', + 'boost', + 'data', + 'data-tools', + 'draggable-points', + 'static-scale', + 'broken-axis', + 'heatmap', + 'tilemap', + 'tiledwebmap', + 'timeline', + 'treemap', + 'treegraph', + 'item-series', + 'drilldown', + 'histogram-bellcurve', + 'bullet', + 'funnel', + 'funnel3d', + 'geoheatmap', + 'pyramid3d', + 'networkgraph', + 'overlapping-datalabels', + 'pareto', + 'pattern-fill', + 'pictorial', + 'price-indicator', + 'sankey', + 'arc-diagram', + 'dependency-wheel', + 'series-label', + 'series-on-point', + 'solid-gauge', + 'sonification', + // 'stock-tools', + 'streamgraph', + 'sunburst', + 'variable-pie', + 'variwide', + 'vector', + 'venn', + 'windbarb', + 'wordcloud', + 'xrange', + 'no-data-to-display', + 'drag-panes', + 'debugger', + 'dumbbell', + 'lollipop', + 'cylinder', + 'organization', + 'dotplot', + 'marker-clusters', + 'hollowcandlestick', + 'heikinashi', + 'flowmap', + 'export-data', + 'navigator', + 'textpath' + ], + indicatorScripts: ['indicators-all'], + customScripts: [ + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js', + 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js' + ] + }); + + // export + tests.export('export', { + infile: null, + instr: null, + options: null, + svg: null, + outfile: null, + type: 'png', + constr: 'chart', + b64: false, + noDownload: false, + defaultHeight: 400, + defaultWidth: 600, + defaultScale: 1, + height: null, + width: null, + scale: null, + globalOptions: null, + themeOptions: null, + batch: null, + rasterizationTimeout: 1500 + }); + + // customLogic + tests.customLogic('customLogic', { + allowCodeExecution: false, + allowFileResources: false, + customCode: null, + callback: null, + resources: null, + loadConfig: null, + createConfig: null + }); + + // server + tests.server('server', { + enable: false, + host: '0.0.0.0', + port: 7801, + benchmarking: false, + proxy: { + host: null, + port: null, + timeout: 5000 + }, + rateLimiting: { + enable: false, + maxRequests: 10, + window: 1, + delay: 0, + trustProxy: false, + skipKey: null, + skipToken: null + }, + ssl: { + enable: false, + force: false, + port: 443, + certPath: null + } + }); + + // pool + tests.pool('pool', { + minWorkers: 4, + maxWorkers: 8, + workLimit: 40, + acquireTimeout: 5000, + createTimeout: 5000, + destroyTimeout: 5000, + idleTimeout: 30000, + createRetryInterval: 200, + reaperInterval: 1000, + benchmarking: false + }); + + // logging + tests.logging('logging', { + level: 4, + file: 'highcharts-export-server.log', + dest: 'log', + toConsole: true, + toFile: true + }); + + // ui + tests.ui('ui', { + enable: false, + route: '/' + }); + + // other + tests.other('other', { + nodeEnv: 'production', + listenToProcessExits: true, + noLogo: false, + hardResetPage: false, + browserShellMode: true + }); + + // debug + tests.debug('debug', { + enable: false, + headless: true, + devtools: false, + listenToConsole: false, + dumpio: false, + slowMo: 0, + debuggingPort: 9222 + }); + + // payload + tests.payload('payload', { + requestId: 'd4faa416-0e85-433a-9f84-e735567d8fa5' + }); +}); + +describe('Puppeteer configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.puppeteer, true); + + // puppeteer.args + tests.puppeteerArgs( + 'args', + [ + '--disable-sync', + '--enable-unsafe-webgpu', + '--hide-crash-restore-bubble', + '--hide-scrollbars', + '--metrics-recording-only' + ], + [ + '--disable-sync', + '--enable-unsafe-webgpu', + '--hide-crash-restore-bubble', + '--hide-scrollbars', + '--metrics-recording-only' + ] + ); +}); + +describe('Highcharts configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.highcharts, true); + + // highcharts.version + tests.highchartsVersion('version'); + + // highcharts.cdnUrl + tests.highchartsCdnUrl( + 'cdnUrl', + ['http://example.com', 'https://example.com'], + ['http:a.com', 'http:/b.com', 'https:c.com', 'https:/d.com'] + ); + + // highcharts.forceFetch + tests.highchartsForceFetch('forceFetch'); + + // highcharts.cachePath + tests.highchartsCachePath('cachePath'); + + // highcharts.coreScripts + tests.highchartsCoreScripts( + 'coreScripts', + ['highcharts', 'highcharts-more', 'text1', 'highcharts-3d', 'text2'], + ['highcharts', 'highcharts-more', 'highcharts-3d'] + ); + + // highcharts.moduleScripts + tests.highchartsModuleScripts( + 'moduleScripts', + ['data', 'text1', 'data-tools', 'text2'], + ['data', 'data-tools'] + ); + + // highcharts.indicatorScripts + tests.highchartsIndicatorScripts( + 'indicatorScripts', + ['text1', 'indicators-all', 'text2'], + ['indicators-all'] + ); + + // highcharts.customScripts + tests.highchartsCustomScripts( + 'customScripts', + [ + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js', + 'text1', + 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js', + 'text2' + ], + [ + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js', + 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js' + ] + ); +}); + +describe('Export configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.export, true); + + // export.infile + tests.exportInfile('infile'); + + // export.instr + tests.exportInstr('instr'); + + // export.options + tests.exportOptions('options'); + + // export.svg + tests.exportSvg('svg'); + + // export.outfile + tests.exportOutfile('outfile'); + + // export.type + tests.exportType( + 'type', + ['jpeg', 'jpg', 'png', 'pdf', 'svg'], + ['json', 'txt'] + ); + + // export.constr + tests.exportConstr( + 'constr', + ['chart', 'stockChart', 'mapChart', 'ganttChart'], + ['stock', 'map', 'gantt'] + ); + + // export.b64 + tests.exportB64('b64'); + + // export.noDownload + tests.exportNoDownload('noDownload'); + + // export.defaultHeight + tests.exportDefaultHeight('defaultHeight'); + + // export.defaultWidth + tests.exportDefaultWidth('defaultWidth'); + + // export.defaultScale + tests.exportDefaultScale('defaultScale'); + + // export.height + tests.exportHeight('height'); + + // export.width + tests.exportWidth('width'); + + // export.scale + tests.exportScale('scale'); + + // export.globalOptions + tests.exportGlobalOptions('globalOptions'); + + // export.themeOptions + tests.exportThemeOptions('themeOptions'); + + // export.batch + tests.exportBatch('batch'); + + // export.rasterizationTimeout + tests.exportRasterizationTimeout('rasterizationTimeout'); +}); + +describe('Custom Logic configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.customLogic, true); + + // customLogic.allowCodeExecution + tests.customLogicAllowCodeExecution('allowCodeExecution'); + + // customLogic.allowFileResources + tests.customLogicAllowFileResources('allowFileResources'); + + // customLogic.customCode + tests.customLogicCustomCode('customCode'); + + // customLogic.callback + tests.customLogicCallback('callback'); + + // customLogic.resources + tests.customLogicResources('resources'); + + // customLogic.loadConfig + tests.customLogicLoadConfig('loadConfig'); + + // customLogic.createConfig + tests.customLogicCreateConfig('createConfig'); +}); + +describe('Server configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.server, true); + + // server.enable + tests.serverEnable('enable'); + + // server.host + tests.serverHost('host'); + + // server.port + tests.serverPort('port'); + + // server.benchmarking + tests.serverBenchmarking('benchmarking'); + + // server.proxy + tests.serverProxy('proxy', { + host: null, + port: null, + timeout: 5000 + }); + + // server.rateLimiting + tests.serverRateLimiting('rateLimiting', { + enable: false, + maxRequests: 10, + window: 1, + delay: 0, + trustProxy: false, + skipKey: null, + skipToken: null + }); + + // server.ssl + tests.serverSsl('ssl', { + enable: false, + force: false, + port: 443, + certPath: null + }); +}); + +describe('Server Proxy configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.server.shape.proxy, true); + + // server.proxy.host + tests.serverProxyHost('host'); + + // server.proxy.port + tests.serverProxyPort('port'); + + // server.proxy.timeout + tests.serverProxyTimeout('timeout'); +}); + +describe('Server Rate Limiting configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests( + StrictConfigSchema.shape.server.shape.rateLimiting, + true + ); + + // server.rateLimiting.enable + tests.serverRateLimitingEnable('enable'); + + // server.rateLimiting.maxRequests + tests.serverRateLimitingMaxRequests('maxRequests'); + + // server.rateLimiting.window + tests.serverRateLimitingWindow('window'); + + // server.rateLimiting.delay + tests.serverRateLimitingDelay('delay'); + + // server.rateLimiting.trustProxy + tests.serverRateLimitingTrustProxy('trustProxy'); + + // server.rateLimiting.skipKey + tests.serverRateLimitingSkipKey('skipKey'); + + // server.rateLimiting.skipToken + tests.serverRateLimitingSkipToken('skipToken'); +}); + +describe('Server SSL configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.server.shape.ssl, true); + + // server.ssl.enable + tests.serverSslEnable('enable'); + + // server.ssl.force + tests.serverSslForce('force'); + + // server.ssl.port + tests.serverSslPort('port'); + + // server.ssl.certPath + tests.serverSslCertPath('certPath'); +}); + +describe('Pool configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.pool, true); + + // pool.minWorkers + tests.poolMinWorkers('minWorkers'); + + // pool.maxWorkers + tests.poolMaxWorkers('maxWorkers'); + + // pool.workLimit + tests.poolWorkLimit('workLimit'); + + // pool.acquireTimeout + tests.poolAcquireTimeout('acquireTimeout'); + + // pool.createTimeout + tests.poolCreateTimeout('createTimeout'); + + // pool.destroyTimeout + tests.poolDestroyTimeout('destroyTimeout'); + + // pool.idleTimeout + tests.poolIdleTimeout('idleTimeout'); + + // pool.createRetryInterval + tests.poolCreateRetryInterval('createRetryInterval'); + + // pool.reaperInterval + tests.poolReaperInterval('reaperInterval'); + + // pool.benchmarking + tests.poolBenchmarking('benchmarking'); +}); + +describe('Logging configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.logging, true); + + // logging.level + tests.loggingLevel('level'); + + // logging.file + tests.loggingFile('file'); + + // logging.dest + tests.loggingDest('dest'); + + // logging.toConsole + tests.loggingToConsole('toConsole'); + + // logging.toFile + tests.loggingToFile('toFile'); +}); + +describe('UI configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.ui, true); + + // ui.enable + tests.uiEnable('enable'); + + // ui.route + tests.uiRoute('route', ['/', '/ui'], ['ui', 'example/ui/']); +}); + +describe('Other configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.other, true); + + // other.nodeEnv + tests.otherNodeEnv( + 'nodeEnv', + ['development', 'production', 'test'], + ['dev-env', 'prod-env', 'test-env'] + ); + + // other.listenToProcessExits + tests.otherListenToProcessExits('listenToProcessExits'); + + // other.noLogo + tests.otherNoLogo('noLogo'); + + // other.hardResetPage + tests.otherHardResetPage('hardResetPage'); + + // other.browserShellMode + tests.otherBrowserShellMode('browserShellMode'); +}); + +describe('Debug configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.debug, true); + + // debug.enable + tests.debugEnable('enable'); + + // debug.headless + tests.debugHeadless('headless'); + + // debug.devtools + tests.debugDevtools('devtools'); + + // debug.listenToConsole + tests.debugListenToConsole('listenToConsole'); + + // debug.dumpio + tests.debugDumpio('dumpio'); + + // debug.slowMo + tests.debugSlowMo('slowMo'); + + // debug.debuggingPort + tests.debugDebuggingPort('debuggingPort'); +}); + +describe('Payload configuration options should be correctly parsed and validated', () => { + // Return config tests with a specific schema and strictCheck flag injected + const tests = configTests(StrictConfigSchema.shape.payload, true); + + // payload.requestId + tests.payloadRequestId('requestId'); +}); diff --git a/tests/unit/validation/envs.test.js b/tests/unit/validation/envs.test.js new file mode 100644 index 00000000..1b428e27 --- /dev/null +++ b/tests/unit/validation/envs.test.js @@ -0,0 +1,341 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +import { describe } from '@jest/globals'; + +import { configTests } from './shared.js'; +import { EnvSchema } from '../../../lib/validation.js'; + +// Return config tests with a specific schema and strictCheck flag injected +const tests = configTests(EnvSchema.partial(), false); + +describe('PUPPETEER environment variables should be correctly parsed and validated', () => { + // PUPPETEER_ARGS + tests.puppeteerArgs( + 'PUPPETEER_ARGS', + '--disable-sync; --enable-unsafe-webgpu; --hide-crash-restore-bubble; --hide-scrollbars; --metrics-recording-only', + [ + '--disable-sync', + '--enable-unsafe-webgpu', + '--hide-crash-restore-bubble', + '--hide-scrollbars', + '--metrics-recording-only' + ] + ); +}); + +describe('HIGHCHARTS environment variables should be correctly parsed and validated', () => { + // HIGHCHARTS_VERSION + tests.highchartsVersion('HIGHCHARTS_VERSION'); + + // HIGHCHARTS_CDN_URL + tests.highchartsCdnUrl( + 'HIGHCHARTS_CDN_URL', + ['http://example.com', 'https://example.com'], + ['http:a.com', 'http:/b.com', 'https:c.com', 'https:/d.com'] + ); + + // HIGHCHARTS_FORCE_FETCH + tests.highchartsForceFetch('HIGHCHARTS_FORCE_FETCH'); + + // HIGHCHARTS_CACHE_PATH + tests.highchartsCachePath('HIGHCHARTS_CACHE_PATH'); + + // HIGHCHARTS_ADMIN_TOKEN + tests.highchartsAdminToken('HIGHCHARTS_ADMIN_TOKEN'); + + // HIGHCHARTS_CORE_SCRIPTS + tests.highchartsCoreScripts( + 'HIGHCHARTS_CORE_SCRIPTS', + 'highcharts, highcharts-more, text1, highcharts-3d, text2', + ['highcharts', 'highcharts-more', 'highcharts-3d'] + ); + + // HIGHCHARTS_MODULE_SCRIPTS + tests.highchartsModuleScripts( + 'HIGHCHARTS_MODULE_SCRIPTS', + 'data, text1, data-tools, text2', + ['data', 'data-tools'] + ); + + // HIGHCHARTS_INDICATOR_SCRIPTS + tests.highchartsIndicatorScripts( + 'HIGHCHARTS_INDICATOR_SCRIPTS', + 'text1, indicators-all, text2', + ['indicators-all'] + ); + + // HIGHCHARTS_CUSTOM_SCRIPTS + tests.highchartsCustomScripts( + 'HIGHCHARTS_CUSTOM_SCRIPTS', + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js, text1, https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js, text2', + [ + 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js', + 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js' + ] + ); +}); + +describe('EXPORT environment variables should be correctly parsed and validated', () => { + // EXPORT_INFILE + tests.exportInfile('EXPORT_INFILE'); + + // EXPORT_INSTR + tests.exportInstr('EXPORT_INSTR'); + + // EXPORT_OPTIONS + tests.exportOptions('EXPORT_OPTIONS'); + + // EXPORT_SVG + tests.exportSvg('EXPORT_SVG'); + + // EXPORT_OUTFILE + tests.exportOutfile('EXPORT_OUTFILE'); + + // EXPORT_TYPE + tests.exportType( + 'EXPORT_TYPE', + ['jpeg', 'jpg', 'png', 'pdf', 'svg'], + ['json', 'txt'] + ); + + // EXPORT_CONSTR + tests.exportConstr( + 'EXPORT_CONSTR', + ['chart', 'stockChart', 'mapChart', 'ganttChart'], + ['stock', 'map', 'gantt'] + ); + + // EXPORT_B64 + tests.exportB64('EXPORT_B64'); + + // EXPORT_NO_DOWNLOAD + tests.exportNoDownload('EXPORT_NO_DOWNLOAD'); + + // EXPORT_DEFAULT_HEIGHT + tests.exportDefaultHeight('EXPORT_DEFAULT_HEIGHT'); + + // EXPORT_DEFAULT_WIDTH + tests.exportDefaultWidth('EXPORT_DEFAULT_WIDTH'); + + // EXPORT_DEFAULT_SCALE + tests.exportDefaultScale('EXPORT_DEFAULT_SCALE'); + + // EXPORT_HEIGHT + tests.exportDefaultHeight('EXPORT_HEIGHT'); + + // EXPORT_WIDTH + tests.exportDefaultWidth('EXPORT_WIDTH'); + + // EXPORT_SCALE + tests.exportDefaultScale('EXPORT_SCALE'); + + // EXPORT_GLOBAL_OPTIONS + tests.exportGlobalOptions('EXPORT_GLOBAL_OPTIONS'); + + // EXPORT_THEME_OPTIONS + tests.exportThemeOptions('EXPORT_THEME_OPTIONS'); + + // EXPORT_BATCH + tests.exportBatch('EXPORT_BATCH'); + + // EXPORT_RASTERIZATION_TIMEOUT + tests.exportRasterizationTimeout('EXPORT_RASTERIZATION_TIMEOUT'); +}); + +describe('CUSTOM_LOGIC environment variables should be correctly parsed and validated', () => { + // CUSTOM_LOGIC_ALLOW_CODE_EXECUTION + tests.customLogicAllowCodeExecution('CUSTOM_LOGIC_ALLOW_CODE_EXECUTION'); + + // CUSTOM_LOGIC_ALLOW_FILE_RESOURCES + tests.customLogicAllowFileResources('CUSTOM_LOGIC_ALLOW_FILE_RESOURCES'); + + // CUSTOM_LOGIC_CUSTOM_CODE + tests.customLogicCustomCode('CUSTOM_LOGIC_CUSTOM_CODE'); + + // CUSTOM_LOGIC_CALLBACK + tests.customLogicCallback('CUSTOM_LOGIC_CALLBACK'); + + // CUSTOM_LOGIC_RESOURCES + tests.customLogicResources('CUSTOM_LOGIC_RESOURCES'); + + // CUSTOM_LOGIC_LOAD_CONFIG + tests.customLogicLoadConfig('CUSTOM_LOGIC_LOAD_CONFIG'); + + // CUSTOM_LOGIC_CREATE_CONFIG + tests.customLogicCreateConfig('CUSTOM_LOGIC_CREATE_CONFIG'); +}); + +describe('SERVER environment variables should be correctly parsed and validated', () => { + // SERVER_ENABLE + tests.serverEnable('SERVER_ENABLE'); + + // SERVER_HOST + tests.serverHost('SERVER_HOST'); + + // SERVER_PORT + tests.serverPort('SERVER_PORT'); + + // SERVER_BENCHMARKING + tests.serverBenchmarking('SERVER_BENCHMARKING'); +}); + +describe('SERVER_PROXY environment variables should be correctly parsed and validated', () => { + // SERVER_PROXY_HOST + tests.serverProxyHost('SERVER_PROXY_HOST'); + + // SERVER_PROXY_PORT + tests.serverProxyPort('SERVER_PROXY_PORT'); + + // SERVER_PROXY_TIMEOUT + tests.serverProxyTimeout('SERVER_PROXY_TIMEOUT'); +}); + +describe('SERVER_RATE_LIMITING environment variables should be correctly parsed and validated', () => { + // SERVER_RATE_LIMITING_ENABLE + tests.serverRateLimitingEnable('SERVER_RATE_LIMITING_ENABLE'); + + // SERVER_RATE_LIMITING_MAX_REQUESTS + tests.serverRateLimitingMaxRequests('SERVER_RATE_LIMITING_MAX_REQUESTS'); + + // SERVER_RATE_LIMITING_WINDOW + tests.serverRateLimitingWindow('SERVER_RATE_LIMITING_WINDOW'); + + // SERVER_RATE_LIMITING_DELAY + tests.serverRateLimitingDelay('SERVER_RATE_LIMITING_DELAY'); + + // SERVER_RATE_LIMITING_TRUST_PROXY + tests.serverRateLimitingTrustProxy('SERVER_RATE_LIMITING_TRUST_PROXY'); + + // SERVER_RATE_LIMITING_SKIP_KEY + tests.serverRateLimitingSkipKey('SERVER_RATE_LIMITING_SKIP_KEY'); + + // SERVER_RATE_LIMITING_SKIP_TOKEN + tests.serverRateLimitingSkipToken('SERVER_RATE_LIMITING_SKIP_TOKEN'); +}); + +describe('SERVER_SSL environment variables should be correctly parsed and validated', () => { + // SERVER_SSL_ENABLE + tests.serverSslEnable('SERVER_SSL_ENABLE'); + + // SERVER_SSL_FORCE + tests.serverSslForce('SERVER_SSL_FORCE'); + + // SERVER_SSL_PORT + tests.serverSslPort('SERVER_SSL_PORT'); + + // SERVER_SSL_CERT_PATH + tests.serverSslCertPath('SERVER_SSL_CERT_PATH'); +}); + +describe('POOL environment variables should be correctly parsed and validated', () => { + // POOL_MIN_WORKERS + tests.poolMinWorkers('POOL_MIN_WORKERS'); + + // POOL_MAX_WORKERS + tests.poolMaxWorkers('POOL_MAX_WORKERS'); + + // POOL_WORK_LIMIT + tests.poolWorkLimit('POOL_WORK_LIMIT'); + + // POOL_ACQUIRE_TIMEOUT + tests.poolAcquireTimeout('POOL_ACQUIRE_TIMEOUT'); + + // POOL_CREATE_TIMEOUT + tests.poolCreateTimeout('POOL_CREATE_TIMEOUT'); + + // POOL_DESTROY_TIMEOUT + tests.poolDestroyTimeout('POOL_DESTROY_TIMEOUT'); + + // POOL_IDLE_TIMEOUT + tests.poolIdleTimeout('POOL_IDLE_TIMEOUT'); + + // POOL_CREATE_RETRY_INTERVAL + tests.poolCreateRetryInterval('POOL_CREATE_RETRY_INTERVAL'); + + // POOL_REAPER_INTERVAL + tests.poolReaperInterval('POOL_REAPER_INTERVAL'); + + // POOL_BENCHMARKING + tests.poolBenchmarking('POOL_BENCHMARKING'); +}); + +describe('LOGGING environment variables should be correctly parsed and validated', () => { + // LOGGING_LEVEL + tests.loggingLevel('LOGGING_LEVEL'); + + // LOGGING_FILE + tests.loggingFile('LOGGING_FILE'); + + // LOGGING_DEST + tests.loggingDest('LOGGING_DEST'); + + // LOGGING_TO_CONSOLE + tests.loggingToConsole('LOGGING_TO_CONSOLE'); + + // LOGGING_TO_FILE + tests.loggingToFile('LOGGING_TO_FILE'); +}); + +describe('UI environment variables should be correctly parsed and validated', () => { + // UI_ENABLE + tests.uiEnable('UI_ENABLE'); + + // UI_ROUTE + tests.uiRoute('UI_ROUTE', ['/', '/ui'], ['ui', 'example/ui/']); +}); + +describe('OTHER environment variables should be correctly parsed and validated', () => { + // OTHER_NODE_ENV + tests.otherNodeEnv( + 'OTHER_NODE_ENV', + ['development', 'production', 'test'], + ['dev-env', 'prod-env', 'test-env'] + ); + + // OTHER_LISTEN_TO_PROCESS_EXITS + tests.otherListenToProcessExits('OTHER_LISTEN_TO_PROCESS_EXITS'); + + // OTHER_NO_LOGO + tests.otherNoLogo('OTHER_NO_LOGO'); + + // OTHER_HARD_RESET_PAGE + tests.otherHardResetPage('OTHER_HARD_RESET_PAGE'); + + // OTHER_BROWSER_SHELL_MODE + tests.otherBrowserShellMode('OTHER_BROWSER_SHELL_MODE'); +}); + +describe('DEBUG environment variables should be correctly parsed and validated', () => { + // DEBUG_ENABLE + tests.debugEnable('DEBUG_ENABLE'); + + // DEBUG_HEADLESS + tests.debugHeadless('DEBUG_HEADLESS'); + + // DEBUG_DEVTOOLS + tests.debugDevtools('DEBUG_DEVTOOLS'); + + // DEBUG_LISTEN_TO_CONSOLE + tests.debugListenToConsole('DEBUG_LISTEN_TO_CONSOLE'); + + // DEBUG_DUMPIO + tests.debugDumpio('DEBUG_DUMPIO'); + + // DEBUG_SLOW_MO + tests.debugSlowMo('DEBUG_SLOW_MO'); + + // DEBUG_DEBUGGING_PORT + tests.debugDebuggingPort('DEBUG_DEBUGGING_PORT'); +}); diff --git a/tests/unit/validation/shared.js b/tests/unit/validation/shared.js new file mode 100644 index 00000000..2f0a015b --- /dev/null +++ b/tests/unit/validation/shared.js @@ -0,0 +1,2565 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +import { describe, expect, it } from '@jest/globals'; + +import { validatePropOfSchema } from '../../utils/testUtils.js'; + +/** + * Runs a series of tests to validate and parse configuration properties using + * the injected schema. Optionally performs strict checks. + * + * @param {Object} schema - The schema used for validation and parsing. + * @param {boolean} strictCheck - A flag indicating whether to enforce strict + * validation. + */ +export function configTests(schema, strictCheck) { + /** + * Verifies that a property with the value undefined is accepted. + * + * @function acceptUndefined + * + * @param {string} property - The property to check for accepting null. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const acceptUndefined = (property) => { + const obj = { [property]: undefined }; + expect(schema.parse(obj)[property]).toBe(undefined); + }; + + /** + * Verifies that a property with the value null is accepted. + * + * @function acceptNull + * + * @param {string} property - The property to check for accepting null. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const acceptNull = (property) => { + const obj = { [property]: null }; + expect(schema.parse(obj)[property]).toBe(null); + }; + + /** + * Verifies that a property with the string value 'null' is converted to null. + * + * @function stringNullToNull + * + * @param {string} property - The property to check for conversion of 'null' + * to null. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const stringNullToNull = (property) => { + const obj = { [property]: 'null' }; + expect(schema.parse(obj)[property]).toBe(null); + }; + + /** + * Verifies that a property with the string value 'undefined' is converted to + * null. + * + * @function stringUndefinedToNull + * + * @param {string} property - The property to check for conversion of + * 'undefined' to null. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const stringUndefinedToNull = (property) => { + const obj = { [property]: 'undefined' }; + expect(schema.parse(obj)[property]).toBe(null); + }; + + /** + * Verifies that a property with the string value '' is converted to null. + * + * @function emptyStringToNull + * + * @param {string} property - The property to check for conversion of '' to + * null. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const emptyStringToNull = (property) => { + const obj = { [property]: '' }; + expect(schema.parse(obj)[property]).toBe(null); + }; + + /** + * Verifies that a property set to null causes a schema validation error. + * + * @function nullThrow + * + * @param {string} property - The property to check for a thrown validation + * error. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const nullThrow = (property) => { + const obj = { [property]: null }; + expect(() => schema.parse(obj)).toThrow(); + }; + + /** + * Verifies that a property set to 'null' causes a schema validation error. + * + * @function stringNullThrow + * + * @param {string} property - The property to check for a thrown validation + * error. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const stringNullThrow = (property) => { + const obj = { [property]: 'null' }; + expect(() => schema.parse(obj)).toThrow(); + }; + + /** + * Verifies that a property set to 'undefined' causes a schema validation + * error. + * + * @function stringUndefinedThrow + * + * @param {string} property - The property to check for a thrown validation + * error. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const stringUndefinedThrow = (property) => { + const obj = { [property]: 'undefined' }; + expect(() => schema.parse(obj)).toThrow(); + }; + + /** + * Verifies that a property set to '' causes a schema validation error. + * + * @function emptyStringThrow + * + * @param {string} property - The property to check for a thrown validation + * error. + * + * @throws {Error} Throws an `Error` if the schema validation fails. + */ + const emptyStringThrow = (property) => { + const obj = { [property]: '' }; + expect(() => schema.parse(obj)).toThrow(); + }; + + /** + * Object that contains all tests for validating and parsing values of the + * options config. + */ + const validationTests = { + /** + * The boolean validator. + */ + boolean(property) { + it('should accept a boolean value', () => { + const obj = { [property]: true }; + expect(schema.parse(obj)[property]).toBe(true); + obj[property] = false; + expect(schema.parse(obj)[property]).toBe(false); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept a stringified boolean value', () => { + const obj = { [property]: 'true' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'false'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['boolean', 'undefined'])); + } else { + it('should accept a stringified boolean value and transform it to a boolean', () => { + const obj = { [property]: 'true' }; + expect(schema.parse(obj)[property]).toBe(true); + obj[property] = 'false'; + expect(schema.parse(obj)[property]).toBe(false); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringBoolean', + 'stringUndefined', + 'stringNull', + 'boolean', + 'undefined', + 'null' + ])); + } + }, + + /** + * The string validator. + */ + string(property, strictCheck) { + it('should accept a string value', () => { + const obj = { [property]: 'text' }; + expect(schema.parse(obj)[property]).toBe('text'); + obj[property] = 'some-other-text'; + expect(schema.parse(obj)[property]).toBe('some-other-text'); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it("should not accept 'false', 'undefined', 'null', '' values", () => { + const obj = { [property]: 'false' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'undefined'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'null'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = ''; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined' + ])); + } else { + it("should accept 'false', 'undefined', 'null', '' values and trasform to null", () => { + const obj = { [property]: 'false' }; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'undefined'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'null'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = ''; + expect(schema.parse(obj)[property]).toBe(null); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringUndefined', + 'stringNull', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined', + 'null' + ])); + } + }, + + /** + * The accept values validator. + */ + acceptValues(property, correctValue, incorrectValue) { + it(`should accept the following ${correctValue.join(', ')} values`, () => { + correctValue.forEach((value) => { + expect(schema.parse({ [property]: value })[property]).toBe(value); + }); + }); + + it(`should not accept the following ${incorrectValue.join(', ')} values`, () => { + incorrectValue.forEach((value) => { + expect(() => schema.parse({ [property]: value })).toThrow(); + }); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['undefined'])); + } else { + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringUndefined', + 'stringNull', + 'undefined', + 'null' + ])); + } + }, + + /** + * The nullable accept values validator. + */ + nullableAcceptValues(property, correctValue, incorrectValue) { + it(`should accept the following ${correctValue.join(', ')} values`, () => { + correctValue.forEach((value) => { + expect(schema.parse({ [property]: value })[property]).toBe(value); + }); + }); + + it(`should not accept the following ${incorrectValue.join(', ')} values`, () => { + incorrectValue.forEach((value) => { + expect(() => schema.parse({ [property]: value })).toThrow(); + }); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['undefined', 'null'])); + } else { + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringUndefined', + 'stringNull', + 'undefined', + 'null' + ])); + } + }, + + /** + * The array of strings validator. + */ + stringArray(property, value, correctValue, separator = ',') { + it('should accept a string value or an array of strings and correctly parse it to an array of strings', () => { + const obj = { [property]: value }; + expect(schema.parse(obj)[property]).toEqual(correctValue); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should accept an empty array', () => { + const obj = { [property]: [] }; + expect(schema.parse(obj)[property]).toEqual([]); + }); + + it('should accept an array of strings and filter it from the forbidden values', () => { + const obj = { + [property]: [...value, 'false', 'undefined', 'null', ''] + }; + expect(schema.parse(obj)[property]).toEqual(correctValue); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['undefined', 'array'])); + } else { + it("should accept a stringified array of the 'values' string and correctly parse it to an array of strings", () => { + const obj = { [property]: `[${value}]` }; + expect(schema.parse(obj)[property]).toEqual(correctValue); + }); + + it('should filter a stringified array of a values string from forbidden values and correctly parse it to an array of strings', () => { + const obj = { + [property]: `[${value}${separator} false${separator} undefined${separator} null${separator}]` + }; + expect(schema.parse(obj)[property]).toEqual(correctValue); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringUndefined', + 'stringNull', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'array', + 'undefined', + 'null' + ])); + } + }, + + /** + * The positive number validator. + */ + positiveNum(property) { + it('should accept a positive number value', () => { + const obj = { [property]: 0.1 }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = 100.5; + expect(schema.parse(obj)[property]).toBe(100.5); + obj[property] = 750; + expect(schema.parse(obj)[property]).toBe(750); + }); + + it('should not accept negative and non-positive number value', () => { + const obj = { [property]: 0 }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = -100; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept stringified negative and non-positive number value', () => { + const obj = { [property]: '0' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '-100'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept a stringified positive number value', () => { + const obj = { [property]: '0.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '100.5'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '750'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } else { + it('should accept a stringified positive number value', () => { + const obj = { [property]: '0.1' }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = '100.5'; + expect(schema.parse(obj)[property]).toBe(100.5); + obj[property] = '750'; + expect(schema.parse(obj)[property]).toBe(750); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The nullable positive number validator. + */ + nullablePositiveNum(property) { + it('should accept a positive number value', () => { + const obj = { [property]: 0.1 }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = 100.5; + expect(schema.parse(obj)[property]).toBe(100.5); + obj[property] = 750; + expect(schema.parse(obj)[property]).toBe(750); + }); + + it('should not accept negative and non-positive number value', () => { + const obj = { [property]: 0 }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = -100; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept stringified negative and non-positive number value', () => { + const obj = { [property]: '0' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '-100'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept a stringified positive number value', () => { + const obj = { [property]: '0.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '100.5'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '750'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } else { + it('should accept a stringified positive number value', () => { + const obj = { [property]: '0.1' }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = '100.5'; + expect(schema.parse(obj)[property]).toBe(100.5); + obj[property] = '750'; + expect(schema.parse(obj)[property]).toBe(750); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The non-negative number validator. + */ + nonNegativeNum(property) { + it('should accept a non-negative number value', () => { + const obj = { [property]: 0 }; + expect(schema.parse(obj)[property]).toBe(0); + obj[property] = 1000; + expect(schema.parse(obj)[property]).toBe(1000); + }); + + it('should not accept a negative number value', () => { + const obj = { [property]: -1000 }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept a stringified negative number value', () => { + const obj = { [property]: '-1000' }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept a stringified non-negative number value', () => { + const obj = { [property]: '0' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1000'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } else { + it('should accept a stringified non-negative number value', () => { + const obj = { [property]: '0' }; + expect(schema.parse(obj)[property]).toBe(0); + obj[property] = '1000'; + expect(schema.parse(obj)[property]).toBe(1000); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The nullable non-negative number validator. + */ + nullableNonNegativeNum(property) { + it('should accept a non-negative number value', () => { + const obj = { [property]: 0 }; + expect(schema.parse(obj)[property]).toBe(0); + obj[property] = 1000; + expect(schema.parse(obj)[property]).toBe(1000); + }); + + it('should not accept a negative number value', () => { + const obj = { [property]: -1000 }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept a stringified negative number value', () => { + const obj = { [property]: '-1000' }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept a stringified non-negative number value', () => { + const obj = { [property]: '0' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1000'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } else { + it('should accept a stringified non-negative number value', () => { + const obj = { [property]: '0' }; + expect(schema.parse(obj)[property]).toBe(0); + obj[property] = '1000'; + expect(schema.parse(obj)[property]).toBe(1000); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The svg validator. + */ + svg(property) { + it('should accept a string value that starts with the { + const obj = { + [property]: "..." + }; + expect(schema.parse(obj)[property]).toBe( + "..." + ); + obj[property] = + '...'; + expect(schema.parse(obj)[property]).toBe( + '...' + ); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it("should accept 'false', 'undefined', 'null', '' values and trasform to null", () => { + const obj = { [property]: 'false' }; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'undefined'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'null'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = ''; + expect(schema.parse(obj)[property]).toBe(null); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringUndefined', + 'stringNull', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined', + 'null' + ])); + }, + + /** + * The chartConfig validator. + */ + chartConfig(property) { + it('should accept any object values', () => { + const obj = { [property]: {} }; + expect(schema.parse(obj)[property]).toEqual({}); + obj[property] = { a: 1 }; + expect(schema.parse(obj)[property]).toEqual({ a: 1 }); + obj[property] = { a: '1', b: { c: 3 } }; + expect(schema.parse(obj)[property]).toEqual({ a: '1', b: { c: 3 } }); + }); + + it("should accept a string value that starts with the '{' and ends with the '}'", () => { + const obj = { [property]: '{}' }; + expect(schema.parse(obj)[property]).toBe('{}'); + obj[property] = '{ a: 1 }'; + expect(schema.parse(obj)[property]).toBe('{ a: 1 }'); + obj[property] = '{ a: "1", b: { c: 3 } }'; + expect(schema.parse(obj)[property]).toBe('{ a: "1", b: { c: 3 } }'); + }); + + it('should accept a string value that starts with the { + const obj = { + [property]: "..." + }; + expect(schema.parse(obj)[property]).toBe( + "..." + ); + obj[property] = + '...'; + expect(schema.parse(obj)[property]).toBe( + '...' + ); + }); + + it('should not accept any array values', () => { + const obj = { [property]: [] }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = [1]; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = ['a']; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = [{ a: 1 }]; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept any other object based values', () => { + const obj = { [property]: function () {} }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = () => {}; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = new Date(); + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'undefined', + 'null', + 'emptyString', + 'stringUndefined', + 'stringNull', + 'stringObject', + 'object', + 'other' + ])); + }, + + /** + * The additionalOptions validator. + */ + additionalOptions(property) { + it('should accept any object values', () => { + const obj = { [property]: {} }; + expect(schema.parse(obj)[property]).toEqual({}); + obj[property] = { a: 1 }; + expect(schema.parse(obj)[property]).toEqual({ a: 1 }); + obj[property] = { a: '1', b: { c: 3 } }; + expect(schema.parse(obj)[property]).toEqual({ a: '1', b: { c: 3 } }); + }); + + it("should accept a string value that starts with the '{' and ends with the '}'", () => { + const obj = { [property]: '{}' }; + expect(schema.parse(obj)[property]).toBe('{}'); + obj[property] = '{ a: 1 }'; + expect(schema.parse(obj)[property]).toBe('{ a: 1 }'); + obj[property] = '{ a: "1", b: { c: 3 } }'; + expect(schema.parse(obj)[property]).toBe('{ a: "1", b: { c: 3 } }'); + }); + + it('should accept string values that end with .json', () => { + const obj = { [property]: 'options.json' }; + expect(schema.parse(obj)[property]).toBe('options.json'); + }); + + it('should not accept string values that do not end with .json', () => { + const obj = { [property]: 'options.pdf' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'options.png'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept string values that are not at least one character long without the extensions', () => { + const obj = { [property]: '.json' }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept any array values', () => { + const obj = { [property]: [] }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = [1]; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = ['a']; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = [{ a: 1 }]; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept any other object based values', () => { + const obj = { [property]: function () {} }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = () => {}; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = new Date(); + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'undefined', + 'null', + 'emptyString', + 'stringUndefined', + 'stringNull', + 'stringObject', + 'object', + 'other' + ])); + }, + + /** + * The infile option validator. + */ + infile(property) { + it('should accept string values that end with .json or .svg', () => { + const obj = { [property]: 'chart.json' }; + expect(schema.parse(obj)[property]).toBe('chart.json'); + obj[property] = 'chart.svg'; + expect(schema.parse(obj)[property]).toBe('chart.svg'); + }); + + it('should not accept string values that do not end with .json or .svg', () => { + const obj = { [property]: 'chart.pdf' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'chart.png'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept string values that are not at least one character long without the extensions', () => { + const obj = { [property]: '.json' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.svg'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['undefined', 'null'])); + } else { + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringUndefined', + 'stringNull', + 'undefined', + 'null' + ])); + } + }, + + /** + * The outfile option validator. + */ + outfile(property) { + it('should accept string values that end with .jpeg, .jpg, .png, .pdf, or .svg', () => { + const obj = { [property]: 'chart.jpeg' }; + expect(schema.parse(obj)[property]).toBe('chart.jpeg'); + obj[property] = 'chart.jpg'; + expect(schema.parse(obj)[property]).toBe('chart.jpg'); + obj[property] = 'chart.png'; + expect(schema.parse(obj)[property]).toBe('chart.png'); + obj[property] = 'chart.pdf'; + expect(schema.parse(obj)[property]).toBe('chart.pdf'); + obj[property] = 'chart.svg'; + expect(schema.parse(obj)[property]).toBe('chart.svg'); + }); + + it('should not accept string values that do not end with .jpeg, .jpg, .png, .pdf, or .svg', () => { + const obj = { [property]: 'chart.json' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'chart.txt'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept string values that are not at least one character long without the extensions', () => { + const obj = { [property]: '.jpeg' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.jpg'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.png'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.pdf'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.svg'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['undefined', 'null'])); + } else { + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringUndefined', + 'stringNull', + 'undefined', + 'null' + ])); + } + }, + + /** + * The version option validator. + */ + version(property) { + it("should accept the 'latest' value", () => { + const obj = { [property]: 'latest' }; + expect(schema.parse(obj)[property]).toBe('latest'); + }); + + it('should accept a value in XX, XX.YY, XX.YY.ZZ formats', () => { + const obj = { [property]: '1' }; + expect(schema.parse(obj)[property]).toBe('1'); + obj[property] = '11'; + expect(schema.parse(obj)[property]).toBe('11'); + obj[property] = '1.1'; + expect(schema.parse(obj)[property]).toBe('1.1'); + obj[property] = '1.11'; + expect(schema.parse(obj)[property]).toBe('1.11'); + obj[property] = '11.1'; + expect(schema.parse(obj)[property]).toBe('11.1'); + obj[property] = '11.11'; + expect(schema.parse(obj)[property]).toBe('11.11'); + obj[property] = '1.1.1'; + expect(schema.parse(obj)[property]).toBe('1.1.1'); + obj[property] = '1.1.11'; + expect(schema.parse(obj)[property]).toBe('1.1.11'); + obj[property] = '1.11.1'; + expect(schema.parse(obj)[property]).toBe('1.11.1'); + obj[property] = '1.11.11'; + expect(schema.parse(obj)[property]).toBe('1.11.11'); + obj[property] = '11.1.1'; + expect(schema.parse(obj)[property]).toBe('11.1.1'); + obj[property] = '11.1.11'; + expect(schema.parse(obj)[property]).toBe('11.1.11'); + obj[property] = '11.11.1'; + expect(schema.parse(obj)[property]).toBe('11.11.1'); + obj[property] = '11.11.11'; + expect(schema.parse(obj)[property]).toBe('11.11.11'); + }); + + it('should not accept other string value', () => { + const obj = { [property]: 'string-other-than-latest' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '11a.2.0'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '11.2.123'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'stringNumber', + 'undefined' + ])); + } else { + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'undefined', + 'null' + ])); + } + }, + + /** + * The scale option validator. + */ + scale(property) { + it('should accept number values between the 0.1 and 5.0', () => { + const obj = { [property]: 0.1 }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = 1; + expect(schema.parse(obj)[property]).toBe(1); + obj[property] = 1.5; + expect(schema.parse(obj)[property]).toBe(1.5); + obj[property] = 5; + expect(schema.parse(obj)[property]).toBe(5); + }); + + it('should not accept number values outside the 0.1 and 5.0', () => { + const obj = { [property]: -1.1 }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 0; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 5.5; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept stringified number values outside the 0.1 and 5.0', () => { + const obj = { [property]: '-1.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '0'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '5.5'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept stringified number values between the 0.1 and 5.0', () => { + const obj = { [property]: '0.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1.5'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '5'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['number', 'undefined'])); + } else { + it('should accept stringified number values between the 0.1 and 5.0', () => { + const obj = { [property]: '0.1' }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = '1'; + expect(schema.parse(obj)[property]).toBe(1); + obj[property] = '1.5'; + expect(schema.parse(obj)[property]).toBe(1.5); + obj[property] = '5'; + expect(schema.parse(obj)[property]).toBe(5); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The nullable scale option validator. + */ + nullableScale(property) { + it('should accept number values between the 0.1 and 5.0', () => { + const obj = { [property]: 0.1 }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = 1; + expect(schema.parse(obj)[property]).toBe(1); + obj[property] = 1.5; + expect(schema.parse(obj)[property]).toBe(1.5); + obj[property] = 5; + expect(schema.parse(obj)[property]).toBe(5); + }); + + it('should not accept number values outside the 0.1 and 5.0', () => { + const obj = { [property]: -1.1 }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 0; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 5.5; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept stringified number values outside the 0.1 and 5.0', () => { + const obj = { [property]: '-1.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '0'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '5.5'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept stringified number values between the 0.1 and 5.0', () => { + const obj = { [property]: '0.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1.5'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '5'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'number', + 'undefined', + 'null' + ])); + } else { + it('should accept stringified number values between the 0.1 and 5.0', () => { + const obj = { [property]: '0.1' }; + expect(schema.parse(obj)[property]).toBe(0.1); + obj[property] = '1'; + expect(schema.parse(obj)[property]).toBe(1); + obj[property] = '1.5'; + expect(schema.parse(obj)[property]).toBe(1.5); + obj[property] = '5'; + expect(schema.parse(obj)[property]).toBe(5); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The logLevel option validator. + */ + logLevel(property) { + it('should accept integer number values between the 0 and 5', () => { + const obj = { [property]: 0 }; + expect(schema.parse(obj)[property]).toBe(0); + obj[property] = 1; + expect(schema.parse(obj)[property]).toBe(1); + obj[property] = 3; + expect(schema.parse(obj)[property]).toBe(3); + obj[property] = 5; + expect(schema.parse(obj)[property]).toBe(5); + }); + + it('should not accept float number values between the 0 and 5', () => { + const obj = { [property]: 0.1 }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 1.1; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 3.1; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 4.1; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept stringified float number values between the 0 and 5', () => { + const obj = { [property]: '0.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '1.1'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '3.1'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '4.1'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept number values that fall outside the 0 and 5 range', () => { + const obj = { [property]: -1.1 }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 6; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept stringified number number values that fall outside the 0 and 5 range', () => { + const obj = { [property]: '-1.1' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '6'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['number', 'undefined'])); + } else { + it('should accept stringified number values between the 0 and 5', () => { + const obj = { [property]: '0' }; + expect(schema.parse(obj)[property]).toBe(0); + obj[property] = '1'; + expect(schema.parse(obj)[property]).toBe(1); + obj[property] = '3'; + expect(schema.parse(obj)[property]).toBe(3); + obj[property] = '5'; + expect(schema.parse(obj)[property]).toBe(5); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringNumber', + 'stringUndefined', + 'stringNull', + 'number', + 'undefined', + 'null' + ])); + } + }, + + /** + * The logFile option validator. + */ + logFile(property, strictCheck) { + it('should accept a string value that ends with the .log extension and is at least one character long without the extension', () => { + const obj = { [property]: 'text.log' }; + expect(schema.parse(obj)[property]).toBe('text.log'); + obj[property] = 't.log'; + expect(schema.parse(obj)[property]).toBe('t.log'); + }); + + it('should not accept a string value that does not end with the .log extension or is not at least one character long without the extension', () => { + const obj = { [property]: 'text' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.log'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it("should not accept 'false', 'undefined', 'null', '' values", () => { + const obj = { [property]: 'false' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'undefined'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'null'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = ''; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined' + ])); + } else { + it("should accept 'false', 'undefined', 'null', '' values and trasform to null", () => { + const obj = { [property]: 'false' }; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'undefined'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'null'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = ''; + expect(schema.parse(obj)[property]).toBe(null); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringUndefined', + 'stringNull', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined', + 'null' + ])); + } + }, + + /** + * The resources option validator. + */ + resources(property) { + it("should accept an object with properties 'js', 'css', and 'files'", () => { + const obj = { [property]: { js: '', css: '', files: [] } }; + expect(schema.parse(obj)[property]).toEqual({ + js: null, + css: null, + files: [] + }); + }); + + it("should accept an object with properties 'js', 'css', and 'files' with null values", () => { + const obj = { [property]: { js: null, css: null, files: null } }; + expect(schema.parse(obj)[property]).toEqual({ + js: null, + css: null, + files: null + }); + }); + + it("should accept a partial object with some properties from the 'js', 'css', and 'files'", () => { + const obj = { [property]: { js: 'console.log(1);' } }; + expect(schema.parse(obj)[property]).toEqual({ js: 'console.log(1);' }); + }); + + it("should accept a stringified object with properties 'js', 'css', and 'files'", () => { + const obj = { [property]: "{ js: '', css: '', files: [] }" }; + expect(schema.parse(obj)[property]).toBe( + "{ js: '', css: '', files: [] }" + ); + }); + + it("should accept a stringified object with properties 'js', 'css', and 'files' with null values", () => { + const obj = { [property]: '{ js: null, css: null, files: null }' }; + expect(schema.parse(obj)[property]).toBe( + '{ js: null, css: null, files: null }' + ); + }); + + it("should accept a stringified partial object with some properties from the 'js', 'css', and 'files'", () => { + const obj = { [property]: "{ js: 'console.log(1);' }" }; + expect(schema.parse(obj)[property]).toBe("{ js: 'console.log(1);' }"); + }); + + it('should accept string values that end with .json', () => { + const obj = { [property]: 'resources.json' }; + expect(schema.parse(obj)[property]).toBe('resources.json'); + }); + + it('should not accept string values that do not end with .json', () => { + const obj = { [property]: 'resources.js' }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept string values that are not at least one character long without the extensions', () => { + const obj = { [property]: '.json' }; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + if (strictCheck) { + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'stringObject', + 'object', + 'other', + 'undefined', + 'null' + ])); + } else { + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'stringObject', + 'stringUndefined', + 'stringNull', + 'object', + 'other', + 'undefined', + 'null' + ])); + } + }, + + /** + * The createConfig/loadConfig options validator. + */ + customConfig(property, strictCheck) { + it('should accept a string value that ends with the .json extension and is at least one character long without the extension', () => { + const obj = { [property]: 'text.json' }; + expect(schema.parse(obj)[property]).toBe('text.json'); + obj[property] = 't.json'; + expect(schema.parse(obj)[property]).toBe('t.json'); + }); + + it('should not accept a string value that does not end with the .json extension or is not at least one character long without the extension', () => { + const obj = { [property]: 'text' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = '.json'; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + if (strictCheck) { + it("should not accept 'false', 'undefined', 'null', '' values", () => { + const obj = { [property]: 'false' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'undefined'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'null'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = ''; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept null', () => { + nullThrow(property); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined' + ])); + } else { + it("should accept 'false', 'undefined', 'null', '' values and trasform to null", () => { + const obj = { [property]: 'false' }; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'undefined'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = 'null'; + expect(schema.parse(obj)[property]).toBe(null); + obj[property] = ''; + expect(schema.parse(obj)[property]).toBe(null); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it('should accept a stringified undefined and transform it to null', () => { + stringUndefinedToNull(property); + }); + + it('should accept a stringified null and transform it to null', () => { + stringNullToNull(property); + }); + + it('should accept an empty string and transform it to null', () => { + emptyStringToNull(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'emptyString', + 'string', + 'stringBoolean', + 'stringNumber', + 'stringBigInt', + 'stringUndefined', + 'stringNull', + 'stringSymbol', + 'stringObject', + 'stringArray', + 'stringFunction', + 'stringOther', + 'undefined', + 'null' + ])); + } + }, + + /** + * The config object validator. + */ + configObject(property, value) { + it(`should accept an object with the ${property} properties`, () => { + const obj = { [property]: value }; + expect(schema.parse(obj)[property]).toEqual(value); + }); + + it(`should accept an object with the ${property} properties and filter out other properties`, () => { + const obj = { [property]: { ...value, extraProp: true } }; + expect(schema.parse(obj)[property]).toEqual({ ...value }); + }); + + it(`should accept a partial object with some ${property} properties`, () => { + for (const [key, val] of Object.entries(value)) { + expect( + schema.parse({ [property]: { [key]: val } })[property] + ).toEqual({ [key]: val }); + } + expect( + schema.parse({ [property]: { extraProp: true } })[property] + ).toEqual({}); + }); + + it('should accept object with no properties and transform it to undefined', () => { + const obj = {}; + expect(schema.parse(obj)[property]).toBe(undefined); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, [ + 'undefined', + 'object', + 'other' + ])); + }, + + /** + * The requestId validator. + */ + requestId(property) { + it('should accept a correct UUID string value', () => { + const obj = { [property]: 'b012bde4-8b91-4d68-8b48-cd099358a17f' }; + expect(schema.parse(obj)[property]).toBe( + 'b012bde4-8b91-4d68-8b48-cd099358a17f' + ); + obj[property] = '0694de13-ac56-44f9-813c-1c91674e6a19'; + expect(schema.parse(obj)[property]).toBe( + '0694de13-ac56-44f9-813c-1c91674e6a19' + ); + }); + + it('should accept undefined', () => { + acceptUndefined(property); + }); + + it('should accept null', () => { + acceptNull(property); + }); + + it("should not accept 'false', 'undefined', 'null', '' values", () => { + const obj = { [property]: 'false' }; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'undefined'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = 'null'; + expect(() => schema.parse(obj)).toThrow(); + obj[property] = ''; + expect(() => schema.parse(obj)).toThrow(); + }); + + it('should not accept a stringified undefined', () => { + stringUndefinedThrow(property); + }); + + it('should not accept a stringified null', () => { + stringNullThrow(property); + }); + + it('should not accept an empty string', () => { + emptyStringThrow(property); + }); + + it('should not accept values of other types', () => + validatePropOfSchema(schema, property, ['null', 'undefined'])); + } + }; + + // The options config validation tests + return { + puppeteer: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + puppeteerArgs: (property, value, filteredValue) => { + describe(property, () => + validationTests.stringArray(property, value, filteredValue, ';') + ); + }, + highcharts: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + highchartsVersion: (property) => { + describe(property, () => validationTests.version(property)); + }, + highchartsCdnUrl: (property, correctValue, incorrectValue) => { + describe(property, () => + validationTests.acceptValues(property, correctValue, incorrectValue) + ); + }, + highchartsForceFetch: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + highchartsCachePath: (property) => { + describe(property, () => validationTests.string(property, strictCheck)); + }, + highchartsAdminToken: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + highchartsCoreScripts: (property, value, filteredValue) => { + describe(property, () => + validationTests.stringArray(property, value, filteredValue) + ); + }, + highchartsModuleScripts: (property, value, filteredValue) => { + describe(property, () => + validationTests.stringArray(property, value, filteredValue) + ); + }, + highchartsIndicatorScripts: (property, value, filteredValue) => { + describe(property, () => + validationTests.stringArray(property, value, filteredValue) + ); + }, + highchartsCustomScripts: (property, value, filteredValue) => { + describe(property, () => + validationTests.stringArray(property, value, filteredValue) + ); + }, + export: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + exportInfile: (property) => { + describe(property, () => validationTests.infile(property)); + }, + exportInstr: (property) => { + describe(property, () => validationTests.chartConfig(property, false)); + }, + exportOptions: (property) => { + describe(property, () => validationTests.chartConfig(property, false)); + }, + exportSvg: (property) => { + describe(property, () => validationTests.svg(property)); + }, + exportOutfile: (property) => { + describe(property, () => validationTests.outfile(property)); + }, + exportType: (property, correctValue, incorrectValue) => { + describe(property, () => + validationTests.acceptValues(property, correctValue, incorrectValue) + ); + }, + exportConstr: (property, correctValue, incorrectValue) => { + describe(property, () => + validationTests.acceptValues(property, correctValue, incorrectValue) + ); + }, + exportB64: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + exportNoDownload: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + exportDefaultHeight: (property) => { + describe(property, () => validationTests.positiveNum(property)); + }, + exportDefaultWidth: (property) => { + describe(property, () => validationTests.positiveNum(property)); + }, + exportDefaultScale: (property) => { + describe(property, () => validationTests.scale(property)); + }, + exportHeight: (property) => { + describe(property, () => validationTests.nullablePositiveNum(property)); + }, + exportWidth: (property) => { + describe(property, () => validationTests.nullablePositiveNum(property)); + }, + exportScale: (property) => { + describe(property, () => validationTests.nullableScale(property)); + }, + exportGlobalOptions: (property) => { + describe(property, () => + validationTests.additionalOptions(property, false) + ); + }, + exportThemeOptions: (property) => { + describe(property, () => + validationTests.additionalOptions(property, false) + ); + }, + exportBatch: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + exportRasterizationTimeout: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + customLogic: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + customLogicAllowCodeExecution: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + customLogicAllowFileResources: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + customLogicCustomCode: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + customLogicCallback: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + customLogicResources: (property) => { + describe(property, () => validationTests.resources(property)); + }, + customLogicLoadConfig: (property) => { + describe(property, () => validationTests.customConfig(property, false)); + }, + customLogicCreateConfig: (property) => { + describe(property, () => validationTests.customConfig(property, false)); + }, + server: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + serverEnable: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + serverHost: (property) => { + describe(property, () => validationTests.string(property, strictCheck)); + }, + serverPort: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + serverBenchmarking: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + serverProxy: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + serverProxyHost: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + serverProxyPort: (property) => { + describe(property, () => + validationTests.nullableNonNegativeNum(property) + ); + }, + serverProxyTimeout: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + serverRateLimiting: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + serverRateLimitingEnable: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + serverRateLimitingMaxRequests: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + serverRateLimitingWindow: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + serverRateLimitingDelay: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + serverRateLimitingTrustProxy: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + serverRateLimitingSkipKey: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + serverRateLimitingSkipToken: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + serverSsl: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + serverSslEnable: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + serverSslForce: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + serverSslPort: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + serverSslCertPath: (property) => { + describe(property, () => validationTests.string(property, false)); + }, + pool: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + poolMinWorkers: (property) => { + describe(property, () => validationTests.positiveNum(property)); + }, + poolMaxWorkers: (property) => { + describe(property, () => validationTests.positiveNum(property)); + }, + poolWorkLimit: (property) => { + describe(property, () => validationTests.positiveNum(property)); + }, + poolAcquireTimeout: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + poolCreateTimeout: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + poolDestroyTimeout: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + poolIdleTimeout: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + poolCreateRetryInterval: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + poolReaperInterval: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + poolBenchmarking: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + logging: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + loggingLevel: (property) => { + describe(property, () => validationTests.logLevel(property, strictCheck)); + }, + loggingFile: (property) => { + describe(property, () => validationTests.logFile(property, strictCheck)); + }, + loggingDest: (property) => { + describe(property, () => validationTests.string(property, strictCheck)); + }, + loggingToConsole: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + loggingToFile: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + ui: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + uiEnable: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + uiRoute: (property, correctValue, incorrectValue) => { + describe(property, () => + validationTests.acceptValues(property, correctValue, incorrectValue) + ); + }, + other: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + otherNodeEnv: (property, correctValue, incorrectValue) => { + describe(property, () => + validationTests.acceptValues(property, correctValue, incorrectValue) + ); + }, + otherListenToProcessExits: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + otherNoLogo: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + otherHardResetPage: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + otherBrowserShellMode: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + debug: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + debugEnable: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + debugHeadless: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + debugDevtools: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + debugListenToConsole: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + debugDumpio: (property) => { + describe(property, () => validationTests.boolean(property)); + }, + debugSlowMo: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + debugDebuggingPort: (property) => { + describe(property, () => validationTests.nonNegativeNum(property)); + }, + payload: (property, value) => { + describe(property, () => validationTests.configObject(property, value)); + }, + payloadRequestId: (property) => { + describe(property, () => validationTests.requestId(property)); + } + }; +} diff --git a/tests/utils/testUtils.js b/tests/utils/testUtils.js new file mode 100644 index 00000000..18fd8176 --- /dev/null +++ b/tests/utils/testUtils.js @@ -0,0 +1,129 @@ +/******************************************************************************* + +Highcharts Export Server + +Copyright (c) 2016-2024, Highsoft + +Licenced under the MIT licence. + +Additionally a valid Highcharts license is required for use. + +See LICENSE file in root for details. + +*******************************************************************************/ + +/** + * @overview Provides utilities for Jest tests to validate schema properties + * and test value parsing. This module includes a comprehensive set + * of categorized test values, functions for filtering these values based + * on type categories, and a utility for validating specific schema properties + * against allowed and disallowed types. + */ + +import { expect } from '@jest/globals'; + +/** + * A collection of possible values for various data types used in Jest tests, + * categorized by specific types and their stringified versions. + */ +export const possibleValues = { + // String + emptyString: [''], + string: ['string', '1.0.1.0.1'], + + // Boolean + boolean: [true, false], + stringBoolean: ['true', 'false'], + + // Number + number: [0, 0.1, 1, -1, -0.1, NaN], + stringNumber: ['0', '0.1', '1', '-0.1', 'NaN'], + + // BigInt + bigInt: [BigInt(1)], + stringBigInt: ['BigInt(1)'], + + // Undefined + undefined: [undefined], + stringUndefined: ['undefined'], + + // Null + null: [null], + stringNull: ['null'], + + // Symbol + symbol: [Symbol('a')], + stringSymbol: ["Symbol('a')"], + + // Object + object: [{}, { a: 1 }, { a: '1', b: { c: 3 } }], + stringObject: ['{}', '{ a: 1 }', '{ a: "1", b: { c: 3 } }'], + + // Array objects + array: [[], [1], ['a'], [{ a: 1 }]], + stringArray: ['[]', '[1]', '["a"]', '[{ a: 1 }]'], + + // Function objects + function: [function () {}, () => {}], + stringFunction: ['function () {}', '() => {}'], + + // Other objects + other: [new Date(), new Error(''), new RegExp('abc')], + stringOther: ['new Date()', 'new Error("")', 'new RegExp("abc")'] +}; + +/** + * Filters values from an object based on specified categories. + * + * The function iterates over the entries of the `values` object and collects + * items from the arrays that correspond to keys not present in the `categories` + * array. + * + * @function excludeFromValues + * + * @param {Object} values - An object where keys are category names and values + * are arrays of items. + * @param {Array.} [categories=[]] - An array of category names to be + * excluded from the values. + * + * @returns {Array.<*>} An array of items from the `values` object that are not + * in the specified `categories`. + */ +export function excludeFromValues(values, categories = []) { + const filteredArray = []; + Object.entries(values).forEach(([key, value]) => { + if (!categories.includes(key)) { + filteredArray.push(...value); + } + }); + return filteredArray; +} + +/** + * Validates a specific property of a provided schema by testing it against + * various values and ensuring that values not matching the types in the + * `filterTypes` list throw errors. + * + * The function filters the `possibleValues` object to exclude values of the + * types specified in the `filterTypes` array. It then iterates over the + * remaining values and ensures that parsing those values for the specified + * property in the schema results in an error. + * + * @function validatePropOfSchema + * + * @param {ZodSchema} schema - The Zod schema object to be validated. + * @param {string} property - The property of the schema to be validated. + * @param {Array.} [filterTypes=[]] - An array of type categories to be + * excluded from validation. Values of these types will be skipped in the + * validation process. + */ +export function validatePropOfSchema(schema, property, filterTypes = []) { + // Filter the possibleValues object to exclude values of types from + // the filterTypes array + const otherValues = excludeFromValues(possibleValues, filterTypes); + + // Ensure all other values fail validation + otherValues.forEach((value) => { + expect(() => schema.parse({ [property]: value })).toThrow(); + }); +} From 046ce23ef000a93a2983b2420295b7fb4164db75 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 10 Dec 2024 22:19:27 +0100 Subject: [PATCH 05/19] Corrected an import. --- lib/server/routes/versionChange.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/server/routes/versionChange.js b/lib/server/routes/versionChange.js index a8d9a411..c24e534d 100644 --- a/lib/server/routes/versionChange.js +++ b/lib/server/routes/versionChange.js @@ -18,7 +18,7 @@ See LICENSE file in root for details. */ import { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js'; -import { envs } from '../../envs.js'; +import { envs } from '../../validation.js'; import HttpError from '../../errors/HttpError.js'; From 14a13766c517750b9e9370e0e7dd5d1494d3cb1a Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Sun, 5 Jan 2025 23:19:59 +0100 Subject: [PATCH 06/19] Built scripts. --- dist/index.cjs | 4 ++-- dist/index.esm.js | 2 +- dist/index.esm.js.map | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dist/index.cjs b/dist/index.cjs index 40d941ee..d1dafa20 100644 --- a/dist/index.cjs +++ b/dist/index.cjs @@ -1,2 +1,2 @@ -"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),promises=require("fs/promises"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?e:path.join(__dirname$1,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:n}=logging;if(5!==t&&(0===t||t>n||n>r.length))return;const i=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t.message,{level:n,levelsDesc:i}=logging;if(0===e||e>n||n>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:n,toFile:i}=e;setLogLevel(t),enableConsoleLogging(n),enableFileLogging(o,r,i)}function setLogLevel(e){e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=e}function enableFileLogging(e,t,o){logging.toFile=o,o&&(logging.dest=e,logging.file=t)}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const n=e[r];void 0===n.value?_createNestedProps(n,t,`${o}.${r}`):(t[n.cliName||r]=`${o}.${r}`.substring(1),void 0!==n.legacyName&&(t[n.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const v={array:e=>zod.z.string().transform((t=>t.split(",").map((e=>e.trim())).filter((t=>e.includes(t))))).transform((e=>e.length?e:void 0)),boolean:()=>zod.z.enum(["true","false",""]).transform((e=>""!==e?"true"===e:void 0)),enum:e=>zod.z.enum([...e,""]).transform((e=>""!==e?e:void 0)),string:()=>zod.z.string().trim().refine((e=>!["false","undefined","null","NaN"].includes(e)||""===e),(e=>({message:`The string contains forbidden values, received '${e}'`}))).transform((e=>""!==e?e:void 0)),positiveNum:()=>zod.z.string().trim().refine((e=>""===e||!isNaN(parseFloat(e))&&parseFloat(e)>0),(e=>({message:`The value must be numeric and positive, received '${e}'`}))).transform((e=>""!==e?parseFloat(e):void 0)),nonNegativeNum:()=>zod.z.string().trim().refine((e=>""===e||!isNaN(parseFloat(e))&&parseFloat(e)>=0),(e=>({message:`The value must be numeric and non-negative, received '${e}'`}))).transform((e=>""!==e?parseFloat(e):void 0))},Config=zod.z.object({PUPPETEER_ARGS:v.string(),HIGHCHARTS_VERSION:zod.z.string().trim().refine((e=>/^(latest|\d+(\.\d+){0,2})$/.test(e)||""===e),(e=>({message:`HIGHCHARTS_VERSION must be 'latest', a major version, or in the form XX.YY.ZZ, received '${e}'`}))).transform((e=>""!==e?e:void 0)),HIGHCHARTS_CDN_URL:zod.z.string().trim().refine((e=>e.startsWith("https://")||e.startsWith("http://")||""===e),(e=>({message:`Invalid value for HIGHCHARTS_CDN_URL. It should start with http:// or https://, received '${e}'`}))).transform((e=>""!==e?e:void 0)),HIGHCHARTS_FORCE_FETCH:v.boolean(),HIGHCHARTS_CACHE_PATH:v.string(),HIGHCHARTS_ADMIN_TOKEN:v.string(),HIGHCHARTS_CORE_SCRIPTS:v.array(defaultConfig.highcharts.coreScripts.value),HIGHCHARTS_MODULE_SCRIPTS:v.array(defaultConfig.highcharts.moduleScripts.value),HIGHCHARTS_INDICATOR_SCRIPTS:v.array(defaultConfig.highcharts.indicatorScripts.value),HIGHCHARTS_CUSTOM_SCRIPTS:v.array(defaultConfig.highcharts.customScripts.value),EXPORT_INFILE:v.string(),EXPORT_INSTR:v.string(),EXPORT_OPTIONS:v.string(),EXPORT_SVG:v.string(),EXPORT_BATCH:v.string(),EXPORT_OUTFILE:v.string(),EXPORT_TYPE:v.enum(["jpeg","png","pdf","svg"]),EXPORT_CONSTR:v.enum(["chart","stockChart","mapChart","ganttChart"]),EXPORT_B64:v.boolean(),EXPORT_NO_DOWNLOAD:v.boolean(),EXPORT_HEIGHT:v.positiveNum(),EXPORT_WIDTH:v.positiveNum(),EXPORT_SCALE:v.positiveNum(),EXPORT_DEFAULT_HEIGHT:v.positiveNum(),EXPORT_DEFAULT_WIDTH:v.positiveNum(),EXPORT_DEFAULT_SCALE:v.positiveNum(),EXPORT_GLOBAL_OPTIONS:v.string(),EXPORT_THEME_OPTIONS:v.string(),EXPORT_RASTERIZATION_TIMEOUT:v.nonNegativeNum(),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:v.boolean(),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:v.boolean(),CUSTOM_LOGIC_CUSTOM_CODE:v.string(),CUSTOM_LOGIC_CALLBACK:v.string(),CUSTOM_LOGIC_RESOURCES:v.string(),CUSTOM_LOGIC_LOAD_CONFIG:v.string(),CUSTOM_LOGIC_CREATE_CONFIG:v.string(),SERVER_ENABLE:v.boolean(),SERVER_HOST:v.string(),SERVER_PORT:v.positiveNum(),SERVER_UPLOAD_LIMIT:v.positiveNum(),SERVER_BENCHMARKING:v.boolean(),SERVER_PROXY_HOST:v.string(),SERVER_PROXY_PORT:v.positiveNum(),SERVER_PROXY_TIMEOUT:v.nonNegativeNum(),SERVER_RATE_LIMITING_ENABLE:v.boolean(),SERVER_RATE_LIMITING_MAX_REQUESTS:v.nonNegativeNum(),SERVER_RATE_LIMITING_WINDOW:v.nonNegativeNum(),SERVER_RATE_LIMITING_DELAY:v.nonNegativeNum(),SERVER_RATE_LIMITING_TRUST_PROXY:v.boolean(),SERVER_RATE_LIMITING_SKIP_KEY:v.string(),SERVER_RATE_LIMITING_SKIP_TOKEN:v.string(),SERVER_SSL_ENABLE:v.boolean(),SERVER_SSL_FORCE:v.boolean(),SERVER_SSL_PORT:v.positiveNum(),SERVER_SSL_CERT_PATH:v.string(),POOL_MIN_WORKERS:v.nonNegativeNum(),POOL_MAX_WORKERS:v.nonNegativeNum(),POOL_WORK_LIMIT:v.positiveNum(),POOL_ACQUIRE_TIMEOUT:v.nonNegativeNum(),POOL_CREATE_TIMEOUT:v.nonNegativeNum(),POOL_DESTROY_TIMEOUT:v.nonNegativeNum(),POOL_IDLE_TIMEOUT:v.nonNegativeNum(),POOL_CREATE_RETRY_INTERVAL:v.nonNegativeNum(),POOL_REAPER_INTERVAL:v.nonNegativeNum(),POOL_BENCHMARKING:v.boolean(),LOGGING_LEVEL:zod.z.string().trim().refine((e=>""===e||!isNaN(parseFloat(e))&&parseFloat(e)>=0&&parseFloat(e)<=5),(e=>({message:`Invalid value for LOGGING_LEVEL. We only accept values from 0 to 5 as logging levels, received '${e}'`}))).transform((e=>""!==e?parseFloat(e):void 0)),LOGGING_FILE:v.string(),LOGGING_DEST:v.string(),LOGGING_TO_CONSOLE:v.boolean(),LOGGING_TO_FILE:v.boolean(),UI_ENABLE:v.boolean(),UI_ROUTE:v.string(),OTHER_NODE_ENV:v.enum(["development","production","test"]),OTHER_LISTEN_TO_PROCESS_EXITS:v.boolean(),OTHER_NO_LOGO:v.boolean(),OTHER_HARD_RESET_PAGE:v.boolean(),OTHER_BROWSER_SHELL_MODE:v.boolean(),DEBUG_ENABLE:v.boolean(),DEBUG_HEADLESS:v.boolean(),DEBUG_DEVTOOLS:v.boolean(),DEBUG_LISTEN_TO_CONSOLE:v.boolean(),DEBUG_DUMPIO:v.boolean(),DEBUG_SLOW_MO:v.nonNegativeNum(),DEBUG_DEBUGGING_PORT:v.positiveNum()}),envs=Config.partial().parse(process.env),globalOptions=_initGlobalOptions(defaultConfig);function getOptions(e=!0){return e?globalOptions:deepCopy(globalOptions)}function setOptions(e={},t=[],o=!1){let r={},n={};t.length&&(r=_loadConfigFile(t),n=_pairArgumentValue(nestedProps,t));const i=getOptions(o);return _updateOptions(defaultConfig,i,r,e,n),i}function mergeOptions(e,t){if(isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],r):void 0!==r?r:e[o];return e}function mapToNewOptions(e){const t={};if("[object Object]"===Object.prototype.toString.call(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,n)=>t[o]=e.length-1===n?r:t[o]||{}),t)}return t}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,r]of Object.entries(e))t[o]=Object.prototype.hasOwnProperty.call(r,"value")?r.value:_initGlobalOptions(r);return t}function _updateOptions(e,t,o,r,n){Object.keys(e).forEach((i=>{const s=e[i],a=o&&o[i],l=r&&r[i],c=n&&n[i];if(void 0===s.value)_updateOptions(s,t[i],a,l,c);else{null!=a&&(t[i]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[i]=e),null!=l&&(t[i]=l),null!=c&&(t[i]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e){const t=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),o=t>-1&&e[t+1];if(o)try{return JSON.parse(fs.readFileSync(getAbsolutePath(o)))}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${o} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let r=0;r{if(i.length-1===s){const i=t[++r];i||log(2,`[config] Missing value for the CLI '--${n}' argument. Using the default value.`),e[o]=i||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){let o;const r=getCachePath(),n=path.join(r,"manifest.json"),i=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(n)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let r=!1;const s=JSON.parse(fs.readFileSync(n));if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const n=await fetch(`${e}.js`,t);if(200===n.statusCode&&"string"==typeof n.text){if(o){o[extractModuleName(e)]=1}return n.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${n.statusCode}).`,404).setError(n);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,n){let i;const s=r.host,a=r.port;if(s&&a)try{i=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,n,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,n))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,n=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${n}/${r}/${e}`:`${n}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${n}/maps/${r}/modules/${e}`:`${n}/maps/modules/${e}`:r?`${n}/${r}/modules/${e}`:`${n}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${n}/stock/${r}/indicators/${e}`:`${n}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e){const{getOptions:t,merge:o,setOptions:r,wrap:n}=Highcharts;Highcharts.setOptionsObj=o(!1,{},t()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,r){((t=o(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,r])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const i={chart:{animation:!1,height:e.export.height,width:e.export.width},exporting:{enabled:!1}},s=new Function(`return ${e.export.instr}`)(),a=new Function(`return ${e.export.themeOptions}`)(),l=new Function(`return ${e.export.globalOptions}`)(),c=o(!1,a,s,i),p=e.customLogic.callback?new Function(`return ${e.customLogic.callback}`)():null;e.customLogic.customCode&&new Function("options",e.customLogic.customCode)(s),l&&r(l),Highcharts[e.export.constr]("container",c,p);const u=t();for(const e in u)"function"!=typeof u[e]&&delete u[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...n}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&n};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const n=[];if(r.js&&n.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");n.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of n)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}n.length=0;const i=[];if(r.css){let n=r.css.match(/@import\s*([^;]*);/g);if(n)for(let e of n)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:path.join(__dirname$1,e)}));i.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t){const o=[];try{const r=t.export;let n=!1;if(r.svg){if(log(4,"[export] Treating as SVG input."),"svg"===r.type)return r.svg;n=!0,await _setAsSvg(e,r.svg)}else log(4,"[export] Treating as JSON config."),await _setAsOptions(e,t);o.push(...await addPageResources(e,t.customLogic));const i=n?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(r.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||r.height)),c=Math.abs(Math.ceil(i.chartWidth||r.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:n?1:parseFloat(r.scale)}),r.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,r.type,{width:c,height:l,x:s,y:a},r.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,r.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${r.type}.`,400)}return await clearPageResources(e,o),p}catch(t){return await clearPageResources(e,o),t}}async function _setAsSvg(e,t){await e.setContent(svgTemplate(t),{waitUntil:"domcontentloaded"})}async function _setAsOptions(e,t){await e.evaluate(createChart,t)}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:n}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(n>1?n:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e=getOptions().pool,t=[]){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,getOptions().pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const n=measureTime(),i=await puppeteerExport(t.page,e);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+"Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.").setError(i):new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered during export: ${n()}ms.`).setError(i);e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Exporting a chart sucessfully took ${n()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:n,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${n}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport(e,(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r||`chart.${n}`,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({...e,export:{...e.export,infile:o[0],outfile:o[1]}},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{log(4,"[chart] Starting the exporting process.");const o=mergeOptions(getOptions(!1),e),r=o.export;if(null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=e;else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=e}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:n}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||n?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||n?.sourceHeight||r?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||n?.sourceWidth||r?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let n=e,i=!1;if(t&&e.endsWith(".json"))try{n=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else n=isAllowedConfig(e,!1,o),n&&!t&&delete n.files;for(const e in n)r.includes(e)?i||(i=!0):delete n[e];return i?(n.files&&(n.files=n.files.map((e=>e.trim())),(!n.files||n.files.length<=0)&&delete n.files),n):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:n,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:n,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t=getOptions().server.rateLimiting){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={max:t.maxRequests||30,window:t.window||1,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||!1,skipToken:t.skipToken||!1};r.trustProxy&&e.enable("trust proxy");const n=rateLimit({windowMs:60*r.window*1e3,max:r.max,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>!1!==r.skipKey&&!1!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(n),log(3,`[rate limiting] Enabled rate limiting with ${r.max} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}class HttpError extends ExportError{constructor(e,t){super(e,t)}setStatus(e){return this.statusCode=e,this}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new HttpError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4().replace(/-/g,"");if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new HttpError("[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.",400);const n=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,n);if(null===i&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new HttpError("[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.",400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new HttpError("[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.",400);return e.validatedOptions={_requestId:r,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${fixType(t.type)}`,type:fixType(t.type,t.outfile),constr:fixConstr(t.constr),b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,n),themeOptions:isAllowedConfig(t.themeOptions,!0,n)},customLogic:{allowCodeExecution:n,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,n)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const n=e.validatedOptions,i=n._requestId;log(4,`[export] Got an incoming HTTP request with ID ${i}.`),await startExport(n,((n,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(n)throw n;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new HttpError("[export] Unexpected return of the export result from the chart generation. Please check your request data.",400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:n,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),n||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"))),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new HttpError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new HttpError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const n=e.params.newVersion;if(!n)throw new HttpError("[version] No new version supplied.",400);try{await updateHighchartsVersion(n)}catch(e){throw new HttpError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${n}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e=getOptions().server){try{if(!e.enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const t=1024*e.uploadLimit*1024,o=multer.memoryStorage(),r=multer({storage:o,limits:{fieldSize:t}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:t})),app.use(express.urlencoded({extended:!0,limit:t})),app.use(r.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),healthRoutes(app),exportRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){rateLimitingMiddleware(app,e)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=mergeOptions(getOptions(!1),e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={server:server,startServer:startServer,getOptions:getOptions,setOptions:setOptions,mergeOptions:mergeOptions,mapToNewOptions:mapToNewOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,checkAndUpdateCache:checkAndUpdateCache,initPool:initPool,killPool:killPool,log:log,logWithStack:logWithStack,setLogLevel:setLogLevel,enableConsoleLogging:enableConsoleLogging,enableFileLogging:enableFileLogging,shutdownCleanUp:shutdownCleanUp};exports.default=index,exports.initExport=initExport; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/envs.js","../lib/config.js","../lib/fetch.js","../lib/errors/ExportError.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/errors/HttpError.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is 0.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is null.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message. Accepts a variable amount of arguments. Arguments after\r\n * the `level` will be passed directly to `console.log`, and/or will be joined\r\n * and appended to the log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the rest are strings to build a message with.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || error.message;\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - Object containing `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (0 = no logging,\r\n * 1 = error, 2 = warning, 3 = notice, 4 = verbose, or 5 = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (level >= 0 && level <= logging.levelsDesc.length) {\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update options for the console logging\r\n  logging.toConsole = toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path for the log file.\r\n * @param {string} file - The log file name.\r\n * @param {boolean} toFile - The flag for setting the logging to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update options for the file logging\r\n  logging.toFile = toFile;\r\n\r\n  // Set the `dest` and `file` only if the file logging is enabled\r\n  if (toFile) {\r\n    logging.dest = dest;\r\n    logging.file = file;\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file is responsible for parsing the environment variables\r\n * with the 'zod' library. The parsed environment variables are then exported\r\n * to be used in the application as `envs`. We should not use the `process.env`\r\n * directly in the application as these would not be parsed properly.\r\n *\r\n * The environment variables are parsed and validated only once when\r\n * the application starts. We should write a custom validator or a transformer\r\n * for each of the options.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load .env into environment variables\r\ndotenv.config();\r\n\r\n// Object with custom validators and transformers, to avoid repetition\r\n// in the Config object\r\nconst v = {\r\n  // Splits string value into elements in an array, trims every element, checks\r\n  // if an array is correct, if it is empty, and if it is, returns undefined\r\n  array: (filterArray) =>\r\n    z\r\n      .string()\r\n      .transform((value) =>\r\n        value\r\n          .split(',')\r\n          .map((value) => value.trim())\r\n          .filter((value) => filterArray.includes(value))\r\n      )\r\n      .transform((value) => (value.length ? value : undefined)),\r\n\r\n  // Allows only true, false and correctly parse the value to boolean\r\n  // or no value in which case the returned value will be undefined\r\n  boolean: () =>\r\n    z\r\n      .enum(['true', 'false', ''])\r\n      .transform((value) => (value !== '' ? value === 'true' : undefined)),\r\n\r\n  // Allows passed values or no value in which case the returned value will\r\n  // be undefined\r\n  enum: (values) =>\r\n    z\r\n      .enum([...values, ''])\r\n      .transform((value) => (value !== '' ? value : undefined)),\r\n\r\n  // Trims the string value and checks if it is empty or contains stringified\r\n  // values such as false, undefined, null, NaN, if it does, returns undefined\r\n  string: () =>\r\n    z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          !['false', 'undefined', 'null', 'NaN'].includes(value) ||\r\n          value === '',\r\n        (value) => ({\r\n          message: `The string contains forbidden values, received '${value}'`\r\n        })\r\n      )\r\n      .transform((value) => (value !== '' ? value : undefined)),\r\n\r\n  // Allows positive numbers or no value in which case the returned value will\r\n  // be undefined\r\n  positiveNum: () =>\r\n    z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value === '' || (!isNaN(parseFloat(value)) && parseFloat(value) > 0),\r\n        (value) => ({\r\n          message: `The value must be numeric and positive, received '${value}'`\r\n        })\r\n      )\r\n      .transform((value) => (value !== '' ? parseFloat(value) : undefined)),\r\n\r\n  // Allows non-negative numbers or no value in which case the returned value\r\n  // will be undefined\r\n  nonNegativeNum: () =>\r\n    z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value === '' || (!isNaN(parseFloat(value)) && parseFloat(value) >= 0),\r\n        (value) => ({\r\n          message: `The value must be numeric and non-negative, received '${value}'`\r\n        })\r\n      )\r\n      .transform((value) => (value !== '' ? parseFloat(value) : undefined))\r\n};\r\n\r\nexport const Config = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: v.string(),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: z\r\n    .string()\r\n    .trim()\r\n    .refine(\r\n      (value) => /^(latest|\\d+(\\.\\d+){0,2})$/.test(value) || value === '',\r\n      (value) => ({\r\n        message: `HIGHCHARTS_VERSION must be 'latest', a major version, or in the form XX.YY.ZZ, received '${value}'`\r\n      })\r\n    )\r\n    .transform((value) => (value !== '' ? value : undefined)),\r\n  HIGHCHARTS_CDN_URL: z\r\n    .string()\r\n    .trim()\r\n    .refine(\r\n      (value) =>\r\n        value.startsWith('https://') ||\r\n        value.startsWith('http://') ||\r\n        value === '',\r\n      (value) => ({\r\n        message: `Invalid value for HIGHCHARTS_CDN_URL. It should start with http:// or https://, received '${value}'`\r\n      })\r\n    )\r\n    .transform((value) => (value !== '' ? value : undefined)),\r\n  HIGHCHARTS_FORCE_FETCH: v.boolean(),\r\n  HIGHCHARTS_CACHE_PATH: v.string(),\r\n  HIGHCHARTS_ADMIN_TOKEN: v.string(),\r\n  HIGHCHARTS_CORE_SCRIPTS: v.array(defaultConfig.highcharts.coreScripts.value),\r\n  HIGHCHARTS_MODULE_SCRIPTS: v.array(\r\n    defaultConfig.highcharts.moduleScripts.value\r\n  ),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: v.array(\r\n    defaultConfig.highcharts.indicatorScripts.value\r\n  ),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: v.array(\r\n    defaultConfig.highcharts.customScripts.value\r\n  ),\r\n\r\n  // export\r\n  EXPORT_INFILE: v.string(),\r\n  EXPORT_INSTR: v.string(),\r\n  EXPORT_OPTIONS: v.string(),\r\n  EXPORT_SVG: v.string(),\r\n  EXPORT_BATCH: v.string(),\r\n  EXPORT_OUTFILE: v.string(),\r\n  EXPORT_TYPE: v.enum(['jpeg', 'png', 'pdf', 'svg']),\r\n  EXPORT_CONSTR: v.enum(['chart', 'stockChart', 'mapChart', 'ganttChart']),\r\n  EXPORT_B64: v.boolean(),\r\n  EXPORT_NO_DOWNLOAD: v.boolean(),\r\n  EXPORT_HEIGHT: v.positiveNum(),\r\n  EXPORT_WIDTH: v.positiveNum(),\r\n  EXPORT_SCALE: v.positiveNum(),\r\n  EXPORT_DEFAULT_HEIGHT: v.positiveNum(),\r\n  EXPORT_DEFAULT_WIDTH: v.positiveNum(),\r\n  EXPORT_DEFAULT_SCALE: v.positiveNum(),\r\n  EXPORT_GLOBAL_OPTIONS: v.string(),\r\n  EXPORT_THEME_OPTIONS: v.string(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: v.nonNegativeNum(),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: v.boolean(),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: v.boolean(),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: v.string(),\r\n  CUSTOM_LOGIC_CALLBACK: v.string(),\r\n  CUSTOM_LOGIC_RESOURCES: v.string(),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: v.string(),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: v.string(),\r\n\r\n  // server\r\n  SERVER_ENABLE: v.boolean(),\r\n  SERVER_HOST: v.string(),\r\n  SERVER_PORT: v.positiveNum(),\r\n  SERVER_UPLOAD_LIMIT: v.positiveNum(),\r\n  SERVER_BENCHMARKING: v.boolean(),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: v.string(),\r\n  SERVER_PROXY_PORT: v.positiveNum(),\r\n  SERVER_PROXY_TIMEOUT: v.nonNegativeNum(),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: v.boolean(),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: v.nonNegativeNum(),\r\n  SERVER_RATE_LIMITING_WINDOW: v.nonNegativeNum(),\r\n  SERVER_RATE_LIMITING_DELAY: v.nonNegativeNum(),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: v.boolean(),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: v.string(),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: v.string(),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: v.boolean(),\r\n  SERVER_SSL_FORCE: v.boolean(),\r\n  SERVER_SSL_PORT: v.positiveNum(),\r\n  SERVER_SSL_CERT_PATH: v.string(),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: v.nonNegativeNum(),\r\n  POOL_MAX_WORKERS: v.nonNegativeNum(),\r\n  POOL_WORK_LIMIT: v.positiveNum(),\r\n  POOL_ACQUIRE_TIMEOUT: v.nonNegativeNum(),\r\n  POOL_CREATE_TIMEOUT: v.nonNegativeNum(),\r\n  POOL_DESTROY_TIMEOUT: v.nonNegativeNum(),\r\n  POOL_IDLE_TIMEOUT: v.nonNegativeNum(),\r\n  POOL_CREATE_RETRY_INTERVAL: v.nonNegativeNum(),\r\n  POOL_REAPER_INTERVAL: v.nonNegativeNum(),\r\n  POOL_BENCHMARKING: v.boolean(),\r\n\r\n  // logger\r\n  LOGGING_LEVEL: z\r\n    .string()\r\n    .trim()\r\n    .refine(\r\n      (value) =>\r\n        value === '' ||\r\n        (!isNaN(parseFloat(value)) &&\r\n          parseFloat(value) >= 0 &&\r\n          parseFloat(value) <= 5),\r\n      (value) => ({\r\n        message: `Invalid value for LOGGING_LEVEL. We only accept values from 0 to 5 as logging levels, received '${value}'`\r\n      })\r\n    )\r\n    .transform((value) => (value !== '' ? parseFloat(value) : undefined)),\r\n  LOGGING_FILE: v.string(),\r\n  LOGGING_DEST: v.string(),\r\n  LOGGING_TO_CONSOLE: v.boolean(),\r\n  LOGGING_TO_FILE: v.boolean(),\r\n\r\n  // ui\r\n  UI_ENABLE: v.boolean(),\r\n  UI_ROUTE: v.string(),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: v.enum(['development', 'production', 'test']),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: v.boolean(),\r\n  OTHER_NO_LOGO: v.boolean(),\r\n  OTHER_HARD_RESET_PAGE: v.boolean(),\r\n  OTHER_BROWSER_SHELL_MODE: v.boolean(),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: v.boolean(),\r\n  DEBUG_HEADLESS: v.boolean(),\r\n  DEBUG_DEVTOOLS: v.boolean(),\r\n  DEBUG_LISTEN_TO_CONSOLE: v.boolean(),\r\n  DEBUG_DUMPIO: v.boolean(),\r\n  DEBUG_SLOW_MO: v.nonNegativeNum(),\r\n  DEBUG_DEBUGGING_PORT: v.positiveNum()\r\n});\r\n\r\nexport const envs = Config.partial().parse(process.env);\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack } from './logger.js';\r\nimport { envs } from './envs.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n/**\r\n * Gets the reference to the global options of the server instance object\r\n * or its copy.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getReference=true] - Optional parameter to decide whether\r\n * to return the reference to the global options of the server instance object\r\n * or return a copy of it. The default value is true.\r\n *\r\n * @returns {Object} The reference to the global options of the server instance\r\n * object or its copy.\r\n */\r\nexport function getOptions(getReference = true) {\r\n  return getReference ? globalOptions : deepCopy(globalOptions);\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server instance, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the first parameter (by default an empty object).\r\n * 5. Options from the CLI.\r\n *\r\n * @function setOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.<string>} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n * @param {boolean} [modifyGlobal=false] - Optional parameter to decide\r\n * whether to update and return the reference to the global options\r\n * of the server instance object or return a copy of it. The default value\r\n * is false.\r\n *\r\n * @returns {Object} The updated general options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setOptions(\r\n  customOptions = {},\r\n  cliArgs = [],\r\n  modifyGlobal = false\r\n) {\r\n  // Object for options loaded via the `loadConfig` option\r\n  let configOptions = {};\r\n\r\n  // Object for options from the CLI\r\n  let cliOptions = {};\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs.length) {\r\n    // Get options from the custom JSON loaded via the `loadConfig`\r\n    configOptions = _loadConfigFile(cliArgs);\r\n\r\n    // Get options from the CLI\r\n    cliOptions = _pairArgumentValue(nestedProps, cliArgs);\r\n  }\r\n\r\n  // Get the reference to the global options object or a copy of the object\r\n  const generalOptions = getOptions(modifyGlobal);\r\n\r\n  // Update values of the general options with values from each source possible\r\n  _updateOptions(\r\n    defaultConfig,\r\n    generalOptions,\r\n    configOptions,\r\n    customOptions,\r\n    cliOptions\r\n  );\r\n\r\n  // Return options\r\n  return generalOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `newOptions` is a correct object\r\n  if (isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key];\r\n    }\r\n  }\r\n\r\n  // Return the result options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (Object.prototype.toString.call(oldOptions) === '[object Object]') {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is false.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is false.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is false.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'))\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg')).toString().bold\r\n        .yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    options[name] = Object.prototype.hasOwnProperty.call(item, 'value')\r\n      ? item.value\r\n      : _initGlobalOptions(item);\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Updates options object with values from various sources, following a specific\r\n * prioritization order. The function checks for values in the following order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The options object that will be updated with values\r\n * from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which may override configuration options.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateOptions(config, options, configOpt, customOpt, cliOpt) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the config entry of a specific option\r\n    const entry = config[key];\r\n\r\n    // Gather values for the options from every possible source, if exists\r\n    const configVal = configOpt && configOpt[key];\r\n    const customVal = customOpt && customOpt[key];\r\n    const cliVal = cliOpt && cliOpt[key];\r\n\r\n    // If the value not found, need to go deeper\r\n    if (typeof entry.value === 'undefined') {\r\n      _updateOptions(entry, options[key], configVal, customVal, cliVal);\r\n    } else {\r\n      // If a value from custom JSON options exists, it take precedence\r\n      if (configVal !== undefined && configVal !== null) {\r\n        options[key] = configVal;\r\n      }\r\n\r\n      // If a value from environment variables exists, it take precedence\r\n      const envVal = envs[entry.envLink];\r\n      if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n        options[key] = envVal;\r\n      }\r\n\r\n      // If a value from user options exists, it take precedence\r\n      if (customVal !== undefined && customVal !== null) {\r\n        options[key] = customVal;\r\n      }\r\n\r\n      // If a value from CLI options exists, it take precedence\r\n      if (cliVal !== undefined && cliVal !== null) {\r\n        options[key] = cliVal;\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n  // Check if the `loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `loadConfig` is present and has a correct value\r\n  if (configFileName) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return JSON.parse(readFileSync(getAbsolutePath(configFileName)));\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options.\r\n * It may include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  setOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  let fetchedModules;\r\n\r\n  // Get the cache path\r\n  const cachePath = getCachePath();\r\n\r\n  // Prepare paths to manifest and sources from the cache folder\r\n  const manifestPath = join(cachePath, 'manifest.json');\r\n  const sourcePath = join(cachePath, 'sources.js');\r\n\r\n  // Create the cache destination if it doesn't exist already\r\n  !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n  // Fetch all the scripts either if the `manifest.json` does not exist\r\n  // or if the `forceFetch` option is enabled\r\n  if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n    log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n    fetchedModules = await _updateCache(\r\n      highchartsOptions,\r\n      serverProxyOptions,\r\n      sourcePath\r\n    );\r\n  } else {\r\n    let requestUpdate = false;\r\n\r\n    // Read the manifest JSON\r\n    const manifest = JSON.parse(readFileSync(manifestPath));\r\n\r\n    // Check if the modules is an array, if so, we rewrite it to a map to make\r\n    // it easier to resolve modules.\r\n    if (manifest.modules && Array.isArray(manifest.modules)) {\r\n      const moduleMap = {};\r\n      manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n      manifest.modules = moduleMap;\r\n    }\r\n\r\n    // Get the actual number of scripts to be fetched\r\n    const { coreScripts, moduleScripts, indicatorScripts } = highchartsOptions;\r\n    const numberOfModules =\r\n      coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n    // Compare the loaded highcharts config with the contents in cache.\r\n    // If there are changes, fetch requested modules and products,\r\n    // and bake them into a giant blob. Save the blob.\r\n    if (manifest.version !== highchartsOptions.version) {\r\n      log(\r\n        2,\r\n        '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n      );\r\n      requestUpdate = true;\r\n    } else if (Object.keys(manifest.modules || {}).length !== numberOfModules) {\r\n      log(\r\n        2,\r\n        '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n      );\r\n      requestUpdate = true;\r\n    } else {\r\n      // Check each module, if anything is missing refetch everything\r\n      requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n        if (!manifest.modules[moduleName]) {\r\n          log(\r\n            2,\r\n            `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n          );\r\n          return true;\r\n        }\r\n      });\r\n    }\r\n\r\n    // Update cache if needed\r\n    if (requestUpdate) {\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n      // Load the sources\r\n      cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n      // Get current modules map\r\n      fetchedModules = manifest.modules;\r\n\r\n      // Extract and save version of currently used Highcharts\r\n      cache.hcVersion = extractVersion(cache.sources);\r\n    }\r\n  }\r\n\r\n  // Finally, save the new manifest, which is basically our current config\r\n  // in a slightly different format\r\n  await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Get the reference to the global options to update to the new version\r\n  const options = getOptions();\r\n\r\n  // Set to the new version\r\n  options.highcharts.version = newVersion;\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is false.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n */\r\nexport async function createChart(options) {\r\n  // Get required functions\r\n  const { getOptions, merge, setOptions, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override userOptions with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in userOptions when forExport is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: options.export.height,\r\n      width: options.export.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${options.export.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${options.export.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(\r\n    `return ${options.export.globalOptions}`\r\n  )();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = options.customLogic.callback\r\n    ? new Function(`return ${options.customLogic.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (options.customLogic.customCode) {\r\n    new Function('options', options.customLogic.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[options.export.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is false.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: join(__dirname, cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, options) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    let isSVG = false;\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await _setAsSvg(page, exportOptions.svg);\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await _setAsOptions(page, options);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, options.customLogic))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the specified page's content with provided export input within\r\n * the window context using the `page.setContent` function.\r\n *\r\n * @async\r\n * @function _setAsSvg\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves after the content is set.\r\n */\r\nasync function _setAsSvg(page, svg) {\r\n  await page.setContent(svgTemplate(svg), {\r\n    waitUntil: 'domcontentloaded'\r\n  });\r\n}\r\n\r\n/**\r\n * Sets the options with specified export input and sizes as configuration into\r\n * the `createChart` function within the window context using\r\n * the `page.evaluate` function.\r\n *\r\n * @async\r\n * @function _setAsOptions\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves after the configuration\r\n * is set.\r\n */\r\nasync function _setAsOptions(page, options) {\r\n  await page.evaluate(createChart, options);\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { getOptions } from './config.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} [poolOptions=getOptions().pool] - Object containing `pool`\r\n * options. The default value is the global pool options of the export server\r\n * instance.\r\n * @param {Array.<string>} [puppeteerArgs=[]] - Additional arguments\r\n * for Puppeteer launch. The default value is an empty array.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(\r\n  poolOptions = getOptions().pool,\r\n  puppeteerArgs = []\r\n) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Kills all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves after the workers are\r\n * killed, the pool is destroyed, and the browser is closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (getOptions().pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          options._requestId\r\n            ? `[benchmark] Request [${options._requestId}] - `\r\n            : '[benchmark] ',\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[pool] ' +\r\n          (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n          `Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Perform an export on a puppeteer level\r\n    const exportCounter = measureTime();\r\n    const result = await puppeteerExport(workerHandle.page, options);\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          '[pool] ' +\r\n            (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n            'Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.'\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          '[pool] ' +\r\n            (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n            `Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        options._requestId\r\n          ? `[benchmark] Request [${options._requestId}] - `\r\n          : '[benchmark] ',\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - Object containing `pool` options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { getOptions, mergeOptions, isAllowedConfig } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { killPool, postWork, getPoolStats } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the image in the provided outfile.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain at least one of the following\r\n * properties: `infile`, `instr`, `options`, or `svg` to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Perform an export\r\n    await startExport(options, async (error, data) => {\r\n      // Exit process when error exists\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // Get the `b64`, `outfile`, and `type` for a chart\r\n      const { b64, outfile, type } = data.options.export;\r\n\r\n      // Save the result\r\n      try {\r\n        if (b64) {\r\n          // As a Base64 string to a txt file\r\n          writeFileSync(\r\n            `${outfile.split('.').shift() || 'chart'}.txt`,\r\n            getBase64(data.result, type)\r\n          );\r\n        } else {\r\n          // As a correct image format\r\n          writeFileSync(\r\n            outfile || `chart.${type}`,\r\n            type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n          );\r\n        }\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error while saving a chart.',\r\n          500\r\n        ).setError(error);\r\n      }\r\n\r\n      // Kill pool and close browser after finishing single export\r\n      await killPool();\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on the information\r\n * in the `batch` option. The `batch` is a string in the following format:\r\n * \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results are saved\r\n * in provided outfiles.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain the `batch` option to generate\r\n * valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              ...options,\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              }\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `customOptions` parameter is an object that\r\n * may be partial or complete set of options. The `endCallback` is called when\r\n * the export is completed, with the `error` object as the first argument\r\n * and the `data` object as the second, which contains the Base64 representation\r\n * of the chart in the `result` property and the full set of export options\r\n * in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing work or upon error occurance of the exporting process. The first\r\n * argument is `error` object and the `data` object is the second, that contains\r\n * the Base64 representation of the chart in the `result` property and the full\r\n * set of export options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(customOptions, endCallback) {\r\n  try {\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Merge the custom options into default ones\r\n    const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n    // Get the export options\r\n    const exportOptions = options.export;\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = fileContent;\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = fileContent;\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n *\r\n * @returns {Object} An object containing the calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is null.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  startExport,\r\n  singleExport,\r\n  batchExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} [rateLimitingOptions=getOptions().server.rateLimiting] -\r\n * Object containing `rateLimiting` options. The default value is the global\r\n * rate limiting options of the export server instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(\r\n  app,\r\n  rateLimitingOptions = getOptions().server.rateLimiting\r\n) {\r\n  try {\r\n    // Check if the rate limiting is enabled\r\n    if (rateLimitingOptions.enable) {\r\n      const msg =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        max: rateLimitingOptions.maxRequests || 30,\r\n        window: rateLimitingOptions.window || 1,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || false,\r\n        skipToken: rateLimitingOptions.skipToken || false\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per windowMs\r\n        max: rateOptions.max,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message: msg });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(msg);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== false &&\r\n            rateOptions.skipToken !== false &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.max} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport ExportError from './ExportError.js';\r\n\r\n/**\r\n * A custom HTTP error class that extends the `ExportError`. Used to handle\r\n * errors with HTTP status codes.\r\n */\r\nclass HttpError extends ExportError {\r\n  /**\r\n   * Creates an instance of the `HttpError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super(message, statusCode);\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {HttpError} The updated instance of the `HttpError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default HttpError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport {\r\n  fixConstr,\r\n  fixType,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new HttpError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the body is not correct.\r\n * @throws {HttpError} Throws an `HttpError` if the chart data from the body\r\n * is not correct.\r\n * @throws {HttpError} Throws an `HttpError` in case of the private range url\r\n * error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid().replace(/-/g, '');\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new HttpError(\r\n        \"[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.\",\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the allowCodeExecution option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new HttpError(\r\n        \"[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.\",\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new HttpError(\r\n        \"[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.\",\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get options from the body and store parsed structure in the request\r\n    request.validatedOptions = {\r\n      // Set the created ID as a `_requestId` property in the validated options\r\n      _requestId: requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${fixType(body.type)}`,\r\n        type: fixType(body.type, body.outfile),\r\n        constr: fixConstr(body.constr),\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    };\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions._requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Got an incoming HTTP request with ID ${requestId}.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new HttpError(\r\n          '[export] Unexpected return of the export result from the chart generation. Please check your request data.',\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(readFileSync(join(__dirname, 'package.json')));\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { envs } from '../../envs.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new HttpError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new HttpError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      const newVersion = request.params.newVersion;\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new HttpError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new HttpError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { getOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts HTTP or/and HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains all server related properties (see\r\n * the `server` section in the `lib/schemas/config.js` file for a reference).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} [serverOptions=getOptions().server] - Object containing\r\n * `server` options. The default value is the global server options\r\n * of the export server instance.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when the server should not be enabled or when no valid Express app\r\n * is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions = getOptions().server) {\r\n  try {\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    healthRoutes(app);\r\n    exportRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - Object containing `rateLimiting`\r\n * options.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  rateLimitingMiddleware(app, rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Cleans up function to trigger before ending process for the graceful\r\n * shutdown.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} exitCode - An exit code for the `process.exit()` function.\r\n */\r\nexport async function shutdownCleanUp(exitCode) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  setOptions,\r\n  mergeOptions,\r\n  mapToNewOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\nimport server, { startServer } from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage. This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n */\r\nexport async function initExport(customOptions) {\r\n  // Get the global options object copy and extend it with the incoming options\r\n  const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp(0);\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp(0);\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp(0);\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  server,\r\n  startServer,\r\n\r\n  // Options\r\n  getOptions,\r\n  setOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Cache\r\n  checkAndUpdateCache,\r\n\r\n  // Pool\r\n  initPool,\r\n  killPool,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n\r\n  // Utils\r\n  shutdownCleanUp\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","v","array","filterArray","z","string","transform","map","filter","boolean","enum","refine","positiveNum","isNaN","parseFloat","nonNegativeNum","Config","object","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","partial","parse","env","_initGlobalOptions","getOptions","getReference","setOptions","customOptions","cliArgs","modifyGlobal","configOptions","cliOptions","_loadConfigFile","_pairArgumentValue","generalOptions","_updateOptions","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","index","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","name","configOpt","customOpt","cliOpt","configVal","customVal","cliVal","envVal","stringifyFunctions","stringify","replaceAll","Error","configIndex","findIndex","arg","configFileName","i","option","async","fetch","url","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","ExportError","constructor","statusCode","super","this","setError","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","indexOf","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","proxyHost","proxyPort","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","additionalOptions","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","customLogicOptions","injectedResources","injectedJs","js","content","files","isLocal","jsResource","addScriptTag","injectedCss","css","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","exportOptions","isSVG","_setAsSvg","_setAsOptions","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","_requestId","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","uuid","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","data","batchExport","batchFunctions","pair","batchResults","allSettled","reason","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","msg","rateOptions","limiter","rateLimit","windowMs","delayMs","handler","format","send","default","skip","query","access_token","HttpError","setStatus","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","requestId","connection","remoteAddress","validatedOptions","params","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","adminToken","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","limit","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","enableRateLimiting","middlewares","shutdownCleanUp","exitCode","exit","initExport","_attachProcessExitListeners","code"],"mappings":"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pC,QAAQI,UACR,CAACS,GAAQK,OAAOP,GAAOpD,KAAK,KAAO,MAClC6D,IACKA,GAASpB,QAAQE,QAAUF,QAAQG,cACrCH,QAAQE,QAAS,EACjBF,QAAQG,aAAc,EACtBgB,aAAa,EAAGC,EAAO,yCACxB,GAGP,CCrOO,MAAMiB,cAAgB,CAC3BC,UAAW,CACT7B,KAAM,CACJvB,MAAO,CACL,mCACA,kBACA,0CACA,2BACA,kCACA,kCACA,wCACA,2CACA,qBACA,4BACA,2CACA,uDACA,6BACA,yBACA,0BACA,+BACA,uBACA,uFACA,yBACA,oCACA,oBACA,0BACA,8CACA,2BACA,0BACA,6BACA,mCACA,wCACA,mCACA,2BACA,kCACA,uBACA,iBACA,yBACA,8BACA,oBACA,2BACA,eACA,6BACA,iBACA,aACA,eACA,sBACA,cACA,yBACA,oBACA,uBAEFqD,MAAO,CAAC,YACRC,QAAS,iBACTC,QAAS,gBACTC,YAAa,+BACbC,cAAe,CACbnG,KAAM,OACNoG,UAAW,OAIjBC,WAAY,CACVC,QAAS,CACP5D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbnG,KAAM,SAGVuG,OAAQ,CACN7D,MAAO,8BACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbnG,KAAM,SAGVwG,WAAY,CACV9D,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbnG,KAAM,WAGVyG,UAAW,CACT/D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbnG,KAAM,SAGV0G,YAAa,CACXhE,MAAO,CAAC,aAAc,kBAAmB,iBACzCqD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbnG,KAAM,cACN2G,aAAc,0DAGlBC,cAAe,CACblE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YAC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"} +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),promises=require("fs/promises"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?e:path.join(__dirname$1,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:n}=logging;if(5!==t&&(0===t||t>n||n>r.length))return;const i=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t.message,{level:n,levelsDesc:i}=logging;if(0===e||e>n||n>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t=[],o){logWithStack(e,null,[`${o} - the following Zod issues occured:`,...t.map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:n,toFile:i}=e;setLogLevel(t),enableConsoleLogging(n),enableFileLogging(o,r,i)}function setLogLevel(e){e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=e}function enableFileLogging(e,t,o){logging.toFile=o,o&&(logging.dest=e,logging.file=t)}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const n=e[r];void 0===n.value?_createNestedProps(n,t,`${o}.${r}`):(t[n.cliName||r]=`${o}.${r}`.substring(1),void 0!==n.legacyName&&(t[n.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","false","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),n=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(i):zod.z.union([n,r]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},config={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json'"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json "}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with '.log'"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:config.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:config.version(e),cdnUrl:config.cdnUrl(e),forceFetch:config.forceFetch(e),cachePath:config.cachePath(e),coreScripts:config.coreScripts(e),moduleScripts:config.moduleScripts(e),indicatorScripts:config.indicatorScripts(e),customScripts:config.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:config.infile(e),instr:config.instr(),options:config.options(),svg:config.svg(),outfile:config.outfile(e),type:config.type(e),constr:config.constr(e),b64:config.b64(e),noDownload:config.noDownload(e),defaultHeight:config.defaultHeight(e),defaultWidth:config.defaultWidth(e),defaultScale:config.defaultScale(e),height:config.height(e),width:config.width(e),scale:config.scale(e),globalOptions:config.globalOptions(),themeOptions:config.themeOptions(),batch:config.batch(!1),rasterizationTimeout:config.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:config.allowCodeExecution(e),allowFileResources:config.allowFileResources(e),customCode:config.customCode(!1),callback:config.callback(!1),resources:config.resources(e),loadConfig:config.loadConfig(!1),createConfig:config.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:config.proxyHost(!1),port:config.proxyPort(e),timeout:config.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:config.enableRateLimiting(e),maxRequests:config.maxRequests(e),window:config.window(e),delay:config.delay(e),trustProxy:config.trustProxy(e),skipKey:config.skipKey(!1),skipToken:config.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:config.enableSsl(e),force:config.sslForce(e),port:config.sslPort(e),certPath:config.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:config.enableServer(e).optional(),host:config.host(e).optional(),port:config.port(e).optional(),benchmarking:config.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:config.minWorkers(e),maxWorkers:config.maxWorkers(e),workLimit:config.workLimit(e),acquireTimeout:config.acquireTimeout(e),createTimeout:config.createTimeout(e),destroyTimeout:config.destroyTimeout(e),idleTimeout:config.idleTimeout(e),createRetryInterval:config.createRetryInterval(e),reaperInterval:config.reaperInterval(e),benchmarking:config.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:config.logLevel(e),file:config.logFile(e),dest:config.logDest(e),toConsole:config.logToConsole(e),toFile:config.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:config.enableUi(e),route:config.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:config.nodeEnv(e),listenToProcessExits:config.listenToProcessExits(e),noLogo:config.noLogo(e),hardResetPage:config.hardResetPage(e),browserShellMode:config.browserShellMode(e)}).partial(),DebugSchema=e=>zod.z.object({enable:config.enableDebug(e),headless:config.headless(e),devtools:config.devtools(e),listenToConsole:config.listenToConsole(e),dumpio:config.dumpio(e),slowMo:config.slowMo(e),debuggingPort:config.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:config.args(!1),HIGHCHARTS_VERSION:config.version(!1),HIGHCHARTS_CDN_URL:config.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:config.forceFetch(!1),HIGHCHARTS_CACHE_PATH:config.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:config.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:config.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:config.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:config.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:config.customScripts(!1),EXPORT_INFILE:config.infile(!1),EXPORT_INSTR:config.instr(),EXPORT_OPTIONS:config.options(),EXPORT_SVG:config.svg(),EXPORT_BATCH:config.batch(!1),EXPORT_OUTFILE:config.outfile(!1),EXPORT_TYPE:config.type(!1),EXPORT_CONSTR:config.constr(!1),EXPORT_B64:config.b64(!1),EXPORT_NO_DOWNLOAD:config.noDownload(!1),EXPORT_HEIGHT:config.height(!1),EXPORT_WIDTH:config.width(!1),EXPORT_SCALE:config.scale(!1),EXPORT_DEFAULT_HEIGHT:config.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:config.defaultWidth(!1),EXPORT_DEFAULT_SCALE:config.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:config.globalOptions(),EXPORT_THEME_OPTIONS:config.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:config.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:config.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:config.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:config.customCode(!1),CUSTOM_LOGIC_CALLBACK:config.callback(!1),CUSTOM_LOGIC_RESOURCES:config.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:config.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:config.createConfig(!1),SERVER_ENABLE:config.enableServer(!1),SERVER_HOST:config.host(!1),SERVER_PORT:config.port(!1),SERVER_UPLOAD_LIMIT:config.uploadLimit(!1),SERVER_BENCHMARKING:config.serverBenchmarking(!1),SERVER_PROXY_HOST:config.proxyHost(!1),SERVER_PROXY_PORT:config.proxyPort(!1),SERVER_PROXY_TIMEOUT:config.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:config.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:config.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:config.window(!1),SERVER_RATE_LIMITING_DELAY:config.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:config.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:config.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:config.skipToken(!1),SERVER_SSL_ENABLE:config.enableSsl(!1),SERVER_SSL_FORCE:config.sslForce(!1),SERVER_SSL_PORT:config.sslPort(!1),SERVER_SSL_CERT_PATH:config.sslCertPath(!1),POOL_MIN_WORKERS:config.minWorkers(!1),POOL_MAX_WORKERS:config.maxWorkers(!1),POOL_WORK_LIMIT:config.workLimit(!1),POOL_ACQUIRE_TIMEOUT:config.acquireTimeout(!1),POOL_CREATE_TIMEOUT:config.createTimeout(!1),POOL_DESTROY_TIMEOUT:config.destroyTimeout(!1),POOL_IDLE_TIMEOUT:config.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:config.createRetryInterval(!1),POOL_REAPER_INTERVAL:config.reaperInterval(!1),POOL_BENCHMARKING:config.poolBenchmarking(!1),LOGGING_LEVEL:config.logLevel(!1),LOGGING_FILE:config.logFile(!1),LOGGING_DEST:config.logDest(!1),LOGGING_TO_CONSOLE:config.logToConsole(!1),LOGGING_TO_FILE:config.logToFile(!1),UI_ENABLE:config.enableUi(!1),UI_ROUTE:config.uiRoute(!1),OTHER_NODE_ENV:config.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:config.listenToProcessExits(!1),OTHER_NO_LOGO:config.noLogo(!1),OTHER_HARD_RESET_PAGE:config.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:config.browserShellMode(!1),DEBUG_ENABLE:config.enableDebug(!1),DEBUG_HEADLESS:config.headless(!1),DEBUG_DEVTOOLS:config.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:config.listenToConsole(!1),DEBUG_DUMPIO:config.dumpio(!1),DEBUG_SLOW_MO:config.slowMo(!1),DEBUG_DEBUGGING_PORT:config.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function validateOption(e,t,o){return config[e](o).parse(t)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}const globalOptions=_initGlobalOptions(defaultConfig);function getOptions(e=!0){return e?globalOptions:deepCopy(globalOptions)}function setOptions(e={},t=[],o=!1){let r={},n={};if(t.length)try{r=strictValidate(_loadConfigFile(t))}catch(e){logZodIssues(1,e.issues,"[config] Custom JSON options validation error")}if(e&&0!==Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Custom options validation error")}if(t.length)try{n=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[config] CLI options validation error")}const i=getOptions(o);return _updateOptions(defaultConfig,i,r,e,n),i}function mergeOptions(e,t){if(isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],r):void 0!==r?r:e[o];return e}function mapToNewOptions(e){const t={};if("[object Object]"===Object.prototype.toString.call(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,n)=>t[o]=e.length-1===n?r:t[o]||{}),t)}return t}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,r]of Object.entries(e))t[o]=Object.prototype.hasOwnProperty.call(r,"value")?r.value:_initGlobalOptions(r);return t}function _updateOptions(e,t,o,r,n){Object.keys(e).forEach((i=>{const s=e[i],a=o&&o[i],l=r&&r[i],c=n&&n[i];if(void 0===s.value)_updateOptions(s,t[i],a,l,c);else{null!=a&&(t[i]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[i]=e),null!=l&&(t[i]=l),null!=c&&(t[i]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e){const t=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),o=t>-1&&e[t+1];if(o)try{return JSON.parse(fs.readFileSync(getAbsolutePath(o)))}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${o} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let r=0;r{if(i.length-1===s){const i=t[++r];i||log(2,`[config] Missing value for the CLI '--${n}' argument. Using the default value.`),e[o]=i||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){let o;const r=getCachePath(),n=path.join(r,"manifest.json"),i=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(n)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let r=!1;const s=JSON.parse(fs.readFileSync(n));if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const n=await fetch(`${e}.js`,t);if(200===n.statusCode&&"string"==typeof n.text){if(o){o[extractModuleName(e)]=1}return n.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${n.statusCode}).`,404).setError(n);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,n){let i;const s=r.host,a=r.port;if(s&&a)try{i=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,n,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,n))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,n=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${n}/${r}/${e}`:`${n}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${n}/maps/${r}/modules/${e}`:`${n}/maps/modules/${e}`:r?`${n}/${r}/modules/${e}`:`${n}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${n}/stock/${r}/indicators/${e}`:`${n}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e){const{getOptions:t,merge:o,setOptions:r,wrap:n}=Highcharts;Highcharts.setOptionsObj=o(!1,{},t()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,r){((t=o(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,r])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const i={chart:{animation:!1,height:e.export.height,width:e.export.width},exporting:{enabled:!1}},s=new Function(`return ${e.export.instr}`)(),a=new Function(`return ${e.export.themeOptions}`)(),l=new Function(`return ${e.export.globalOptions}`)(),c=o(!1,a,s,i),p=e.customLogic.callback?new Function(`return ${e.customLogic.callback}`)():null;e.customLogic.customCode&&new Function("options",e.customLogic.customCode)(s),l&&r(l),Highcharts[e.export.constr]("container",c,p);const u=t();for(const e in u)"function"!=typeof u[e]&&delete u[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...n}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&n};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const n=[];if(r.js&&n.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");n.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of n)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}n.length=0;const i=[];if(r.css){let n=r.css.match(/@import\s*([^;]*);/g);if(n)for(let e of n)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:path.join(__dirname$1,e)}));i.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t){const o=[];try{const r=t.export;let n=!1;if(r.svg){if(log(4,"[export] Treating as SVG input."),"svg"===r.type)return r.svg;n=!0,await _setAsSvg(e,r.svg)}else log(4,"[export] Treating as JSON config."),await _setAsOptions(e,t);o.push(...await addPageResources(e,t.customLogic));const i=n?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(r.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||r.height)),c=Math.abs(Math.ceil(i.chartWidth||r.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:n?1:parseFloat(r.scale)}),r.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,r.type,{width:c,height:l,x:s,y:a},r.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,r.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${r.type}.`,400)}return await clearPageResources(e,o),p}catch(t){return await clearPageResources(e,o),t}}async function _setAsSvg(e,t){await e.setContent(svgTemplate(t),{waitUntil:"domcontentloaded"})}async function _setAsOptions(e,t){await e.evaluate(createChart,t)}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:n}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(n>1?n:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e=getOptions().pool,t=[]){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,getOptions().pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const n=measureTime(),i=await puppeteerExport(t.page,e);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+"Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.").setError(i):new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered during export: ${n()}ms.`).setError(i);e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Exporting a chart sucessfully took ${n()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:n,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${n}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport(e,(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r||`chart.${n}`,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({...e,export:{...e.export,infile:o[0],outfile:o[1]}},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{log(4,"[chart] Starting the exporting process.");const o=mergeOptions(getOptions(!1),e),r=o.export;if(null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))try{r.svg=validateOption("svg",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `svg` option validation error"),e}else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);try{r.instr=validateOption("instr",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `instr` option validation error"),e}}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)};try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Final options validation error")}return postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:n}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||n?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||n?.sourceHeight||r?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||n?.sourceWidth||r?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let n=e,i=!1;if(t&&e.endsWith(".json"))try{n=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else n=isAllowedConfig(e,!1,o),n&&!t&&delete n.files;for(const e in n)r.includes(e)?i||(i=!0):delete n[e];return i?(n.files&&(n.files=n.files.map((e=>e.trim())),(!n.files||n.files.length<=0)&&delete n.files),n):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:n,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:n,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t=getOptions().server.rateLimiting){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={max:t.maxRequests||30,window:t.window||1,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||!1,skipToken:t.skipToken||!1};r.trustProxy&&e.enable("trust proxy");const n=rateLimit({windowMs:60*r.window*1e3,max:r.max,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>!1!==r.skipKey&&!1!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(n),log(3,`[rate limiting] Enabled rate limiting with ${r.max} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}class HttpError extends ExportError{constructor(e,t){super(e,t)}setStatus(e){return this.statusCode=e,this}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new HttpError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4().replace(/-/g,"");if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new HttpError("[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.",400);const n=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,n);if(null===i&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new HttpError("[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.",400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new HttpError("[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.",400);try{e.validatedOptions=looseValidate({_requestId:r,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${fixType(t.type)}`,type:fixType(t.type,t.outfile),constr:fixConstr(t.constr),b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,n),themeOptions:isAllowedConfig(t.themeOptions,!0,n)},customLogic:{allowCodeExecution:n,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,n)}})}catch(e){throw logZodIssues(1,e.issues,"[config] Request options validation error"),new HttpError("The provided options are not correct. Please check if your data is of the correct types.",400)}return o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const n=e.validatedOptions,i=n._requestId;log(4,`[export] Got an incoming HTTP request with ID ${i}.`),await startExport(n,((n,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(n)throw n;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new HttpError("[export] Unexpected return of the export result from the chart generation. Please check your request data.",400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:n,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),n||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"))),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new HttpError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new HttpError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const n=e.params.newVersion;if(!n)throw new HttpError("[version] No new version supplied.",400);try{await updateHighchartsVersion(n)}catch(e){throw new HttpError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${n}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e=getOptions().server){try{if(!e.enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const t=1024*e.uploadLimit*1024,o=multer.memoryStorage(),r=multer({storage:o,limits:{fieldSize:t}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:t})),app.use(express.urlencoded({extended:!0,limit:t})),app.use(r.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),healthRoutes(app),exportRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){rateLimitingMiddleware(app,e)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=mergeOptions(getOptions(!1),e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={server:server,startServer:startServer,getOptions:getOptions,setOptions:setOptions,mergeOptions:mergeOptions,mapToNewOptions:mapToNewOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,checkAndUpdateCache:checkAndUpdateCache,initPool:initPool,killPool:killPool,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:setLogLevel,enableConsoleLogging:enableConsoleLogging,enableFileLogging:enableFileLogging,shutdownCleanUp:shutdownCleanUp};exports.default=index,exports.initExport=initExport; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/config.js","../lib/fetch.js","../lib/errors/ExportError.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/errors/HttpError.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is 0.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is null.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message. Accepts a variable amount of arguments. Arguments after\r\n * the `level` will be passed directly to `console.log`, and/or will be joined\r\n * and appended to the log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the rest are strings to build a message with.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || error.message;\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message about Zod issues with the validation. Optionally,\r\n * a custom message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - The array of Zod issues.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n */\r\nexport function logZodIssues(newLevel, issues = [], customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage} - the following Zod issues occured:`,\r\n      ...issues.map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - Object containing `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (0 = no logging,\r\n * 1 = error, 2 = warning, 3 = notice, 4 = verbose, or 5 = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (level >= 0 && level <= logging.levelsDesc.length) {\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update options for the console logging\r\n  logging.toConsole = toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path for the log file.\r\n * @param {string} file - The log file name.\r\n * @param {boolean} toFile - The flag for setting the logging to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update options for the file logging\r\n  logging.toFile = toFile;\r\n\r\n  // Set the `dest` and `file` only if the file logging is enabled\r\n  if (toFile) {\r\n    logging.dest = dest;\r\n    logging.file = file;\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', 'false', 'undefined', 'null', and ''. The strings\r\n   * 'undefined', 'null', and '' will be transformed to null, the string 'true'\r\n   * will be transformed to the boolean value true, and 'false' will\r\n   * be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', 'false', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The string contains a forbidden value`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: `The value must be numeric and positive`\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: `The value must be numeric and non-negative`\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              value.indexOf('<svg') >= 0 ||\r\n              value.indexOf('<?xml') >= 0 ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that contains '<svg' or '<?xml' or starts with '{' and ends with '}'`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with '.json' or starts with '{' and ends with '}'`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst config = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .json or .svg`\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .json or .svg`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that contains '<svg' or '<?xml'`\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that starts with '{' and ends with '}`\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that ends with '.json'`\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that ends with .json `\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that ends with '.log'`\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return (\r\n      z\r\n        .string()\r\n        /// TO DO: Correct\r\n        .uuid({ message: 'The value must be a stringified UUID' })\r\n        .nullable()\r\n    );\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: config.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: config.version(strictCheck),\r\n      cdnUrl: config.cdnUrl(strictCheck),\r\n      forceFetch: config.forceFetch(strictCheck),\r\n      cachePath: config.cachePath(strictCheck),\r\n      coreScripts: config.coreScripts(strictCheck),\r\n      moduleScripts: config.moduleScripts(strictCheck),\r\n      indicatorScripts: config.indicatorScripts(strictCheck),\r\n      customScripts: config.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: config.infile(strictCheck),\r\n      instr: config.instr(),\r\n      options: config.options(),\r\n      svg: config.svg(),\r\n      outfile: config.outfile(strictCheck),\r\n      type: config.type(strictCheck),\r\n      constr: config.constr(strictCheck),\r\n      b64: config.b64(strictCheck),\r\n      noDownload: config.noDownload(strictCheck),\r\n      defaultHeight: config.defaultHeight(strictCheck),\r\n      defaultWidth: config.defaultWidth(strictCheck),\r\n      defaultScale: config.defaultScale(strictCheck),\r\n      height: config.height(strictCheck),\r\n      width: config.width(strictCheck),\r\n      scale: config.scale(strictCheck),\r\n      globalOptions: config.globalOptions(),\r\n      themeOptions: config.themeOptions(),\r\n      batch: config.batch(false),\r\n      rasterizationTimeout: config.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: config.allowCodeExecution(strictCheck),\r\n      allowFileResources: config.allowFileResources(strictCheck),\r\n      customCode: config.customCode(false),\r\n      callback: config.callback(false),\r\n      resources: config.resources(strictCheck),\r\n      loadConfig: config.loadConfig(false),\r\n      createConfig: config.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: config.proxyHost(false),\r\n      port: config.proxyPort(strictCheck),\r\n      timeout: config.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableRateLimiting(strictCheck),\r\n      maxRequests: config.maxRequests(strictCheck),\r\n      window: config.window(strictCheck),\r\n      delay: config.delay(strictCheck),\r\n      trustProxy: config.trustProxy(strictCheck),\r\n      skipKey: config.skipKey(false),\r\n      skipToken: config.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableSsl(strictCheck),\r\n      force: config.sslForce(strictCheck),\r\n      port: config.sslPort(strictCheck),\r\n      certPath: config.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: config.enableServer(strictCheck).optional(),\r\n    host: config.host(strictCheck).optional(),\r\n    port: config.port(strictCheck).optional(),\r\n    benchmarking: config.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: config.minWorkers(strictCheck),\r\n      maxWorkers: config.maxWorkers(strictCheck),\r\n      workLimit: config.workLimit(strictCheck),\r\n      acquireTimeout: config.acquireTimeout(strictCheck),\r\n      createTimeout: config.createTimeout(strictCheck),\r\n      destroyTimeout: config.destroyTimeout(strictCheck),\r\n      idleTimeout: config.idleTimeout(strictCheck),\r\n      createRetryInterval: config.createRetryInterval(strictCheck),\r\n      reaperInterval: config.reaperInterval(strictCheck),\r\n      benchmarking: config.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: config.logLevel(strictCheck),\r\n      file: config.logFile(strictCheck),\r\n      dest: config.logDest(strictCheck),\r\n      toConsole: config.logToConsole(strictCheck),\r\n      toFile: config.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableUi(strictCheck),\r\n      route: config.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: config.nodeEnv(strictCheck),\r\n      listenToProcessExits: config.listenToProcessExits(strictCheck),\r\n      noLogo: config.noLogo(strictCheck),\r\n      hardResetPage: config.hardResetPage(strictCheck),\r\n      browserShellMode: config.browserShellMode(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableDebug(strictCheck),\r\n      headless: config.headless(strictCheck),\r\n      devtools: config.devtools(strictCheck),\r\n      listenToConsole: config.listenToConsole(strictCheck),\r\n      dumpio: config.dumpio(strictCheck),\r\n      slowMo: config.slowMo(strictCheck),\r\n      debuggingPort: config.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n////\r\n// // Schema for the payload section of options\r\n// const PayloadSchema = () =>\r\n//   z\r\n//     .object({\r\n//       requestId: config.requestId()\r\n//     })\r\n//     .partial();\r\n////\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n  //// payload: PayloadSchema()\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n  //// payload: PayloadSchema()\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: config.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: config.version(false),\r\n  HIGHCHARTS_CDN_URL: config.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: config.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: config.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: config.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: config.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: config.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: config.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: config.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: config.infile(false),\r\n  EXPORT_INSTR: config.instr(),\r\n  EXPORT_OPTIONS: config.options(),\r\n  EXPORT_SVG: config.svg(),\r\n  EXPORT_BATCH: config.batch(false),\r\n  EXPORT_OUTFILE: config.outfile(false),\r\n  EXPORT_TYPE: config.type(false),\r\n  EXPORT_CONSTR: config.constr(false),\r\n  EXPORT_B64: config.b64(false),\r\n  EXPORT_NO_DOWNLOAD: config.noDownload(false),\r\n  EXPORT_HEIGHT: config.height(false),\r\n  EXPORT_WIDTH: config.width(false),\r\n  EXPORT_SCALE: config.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: config.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: config.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: config.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: config.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: config.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: config.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: config.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: config.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: config.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: config.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: config.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: config.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: config.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: config.enableServer(false),\r\n  SERVER_HOST: config.host(false),\r\n  SERVER_PORT: config.port(false),\r\n  SERVER_UPLOAD_LIMIT: config.uploadLimit(false),\r\n  SERVER_BENCHMARKING: config.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: config.proxyHost(false),\r\n  SERVER_PROXY_PORT: config.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: config.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: config.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: config.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: config.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: config.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: config.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: config.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: config.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: config.enableSsl(false),\r\n  SERVER_SSL_FORCE: config.sslForce(false),\r\n  SERVER_SSL_PORT: config.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: config.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: config.minWorkers(false),\r\n  POOL_MAX_WORKERS: config.maxWorkers(false),\r\n  POOL_WORK_LIMIT: config.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: config.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: config.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: config.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: config.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: config.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: config.reaperInterval(false),\r\n  POOL_BENCHMARKING: config.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: config.logLevel(false),\r\n  LOGGING_FILE: config.logFile(false),\r\n  LOGGING_DEST: config.logDest(false),\r\n  LOGGING_TO_CONSOLE: config.logToConsole(false),\r\n  LOGGING_TO_FILE: config.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: config.enableUi(false),\r\n  UI_ROUTE: config.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: config.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: config.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: config.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: config.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: config.browserShellMode(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: config.enableDebug(false),\r\n  DEBUG_HEADLESS: config.headless(false),\r\n  DEBUG_DEVTOOLS: config.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: config.listenToConsole(false),\r\n  DEBUG_DUMPIO: config.dumpio(false),\r\n  DEBUG_SLOW_MO: config.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: config.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates a provided option using the specific validator from the config\r\n * object.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of an option to validate.\r\n * @param {any} option - The option to validate.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {any} The parsed and validated option value.\r\n */\r\nexport function validateOption(name, option, strictCheck) {\r\n  return config[name](strictCheck).parse(option);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate,\r\n  validateOption\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport { envs, looseValidate, strictValidate } from './validation.js';\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n/**\r\n * Gets the reference to the global options of the server instance object\r\n * or its copy.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getReference=true] - Optional parameter to decide whether\r\n * to return the reference to the global options of the server instance object\r\n * or return a copy of it. The default value is true.\r\n *\r\n * @returns {Object} The reference to the global options of the server instance\r\n * object or its copy.\r\n */\r\nexport function getOptions(getReference = true) {\r\n  return getReference ? globalOptions : deepCopy(globalOptions);\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server instance, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the first parameter (by default an empty object).\r\n * 5. Options from the CLI.\r\n *\r\n * @function setOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.<string>} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n * @param {boolean} [modifyGlobal=false] - Optional parameter to decide\r\n * whether to update and return the reference to the global options\r\n * of the server instance object or return a copy of it. The default value\r\n * is false.\r\n *\r\n * @returns {Object} The updated general options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setOptions(\r\n  customOptions = {},\r\n  cliArgs = [],\r\n  modifyGlobal = false\r\n) {\r\n  // Object for options loaded via the `loadConfig` option\r\n  let configOptions = {};\r\n\r\n  // Object for options from the CLI\r\n  let cliOptions = {};\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs.length) {\r\n    try {\r\n      // Validate options from the custom JSON loaded via the `loadConfig`\r\n      configOptions = strictValidate(_loadConfigFile(cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[config] Custom JSON options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Apply custom options if there are any\r\n  if (customOptions && Object.keys(customOptions).length !== 0) {\r\n    try {\r\n      // Validate custom options provided by the user\r\n      customOptions = strictValidate(customOptions);\r\n    } catch (error) {\r\n      logZodIssues(1, error.issues, '[config] Custom options validation error');\r\n    }\r\n  }\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs.length) {\r\n    try {\r\n      // Validate options from the CLI\r\n      cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(1, error.issues, '[config] CLI options validation error');\r\n    }\r\n  }\r\n\r\n  // Get the reference to the global options object or a copy of the object\r\n  const generalOptions = getOptions(modifyGlobal);\r\n\r\n  // Update values of the general options with values from each source possible\r\n  _updateOptions(\r\n    defaultConfig,\r\n    generalOptions,\r\n    configOptions,\r\n    customOptions,\r\n    cliOptions\r\n  );\r\n\r\n  // Return options\r\n  return generalOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `newOptions` is a correct object\r\n  if (isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key];\r\n    }\r\n  }\r\n\r\n  // Return the result options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (Object.prototype.toString.call(oldOptions) === '[object Object]') {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is false.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is false.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is false.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'))\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg')).toString().bold\r\n        .yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    options[name] = Object.prototype.hasOwnProperty.call(item, 'value')\r\n      ? item.value\r\n      : _initGlobalOptions(item);\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Updates options object with values from various sources, following a specific\r\n * prioritization order. The function checks for values in the following order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The options object that will be updated with values\r\n * from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which may override configuration options.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateOptions(config, options, configOpt, customOpt, cliOpt) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the config entry of a specific option\r\n    const entry = config[key];\r\n\r\n    // Gather values for the options from every possible source, if exists\r\n    const configVal = configOpt && configOpt[key];\r\n    const customVal = customOpt && customOpt[key];\r\n    const cliVal = cliOpt && cliOpt[key];\r\n\r\n    // If the value not found, need to go deeper\r\n    if (typeof entry.value === 'undefined') {\r\n      _updateOptions(entry, options[key], configVal, customVal, cliVal);\r\n    } else {\r\n      // If a value from custom JSON options exists, it take precedence\r\n      if (configVal !== undefined && configVal !== null) {\r\n        options[key] = configVal;\r\n      }\r\n\r\n      // If a value from environment variables exists, it take precedence\r\n      const envVal = envs[entry.envLink];\r\n      if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n        options[key] = envVal;\r\n      }\r\n\r\n      // If a value from user options exists, it take precedence\r\n      if (customVal !== undefined && customVal !== null) {\r\n        options[key] = customVal;\r\n      }\r\n\r\n      // If a value from CLI options exists, it take precedence\r\n      if (cliVal !== undefined && cliVal !== null) {\r\n        options[key] = cliVal;\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n  // Check if the `loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `loadConfig` is present and has a correct value\r\n  if (configFileName) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return JSON.parse(readFileSync(getAbsolutePath(configFileName)));\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options.\r\n * It may include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  setOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  let fetchedModules;\r\n\r\n  // Get the cache path\r\n  const cachePath = getCachePath();\r\n\r\n  // Prepare paths to manifest and sources from the cache folder\r\n  const manifestPath = join(cachePath, 'manifest.json');\r\n  const sourcePath = join(cachePath, 'sources.js');\r\n\r\n  // Create the cache destination if it doesn't exist already\r\n  !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n  // Fetch all the scripts either if the `manifest.json` does not exist\r\n  // or if the `forceFetch` option is enabled\r\n  if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n    log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n    fetchedModules = await _updateCache(\r\n      highchartsOptions,\r\n      serverProxyOptions,\r\n      sourcePath\r\n    );\r\n  } else {\r\n    let requestUpdate = false;\r\n\r\n    // Read the manifest JSON\r\n    const manifest = JSON.parse(readFileSync(manifestPath));\r\n\r\n    // Check if the modules is an array, if so, we rewrite it to a map to make\r\n    // it easier to resolve modules.\r\n    if (manifest.modules && Array.isArray(manifest.modules)) {\r\n      const moduleMap = {};\r\n      manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n      manifest.modules = moduleMap;\r\n    }\r\n\r\n    // Get the actual number of scripts to be fetched\r\n    const { coreScripts, moduleScripts, indicatorScripts } = highchartsOptions;\r\n    const numberOfModules =\r\n      coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n    // Compare the loaded highcharts config with the contents in cache.\r\n    // If there are changes, fetch requested modules and products,\r\n    // and bake them into a giant blob. Save the blob.\r\n    if (manifest.version !== highchartsOptions.version) {\r\n      log(\r\n        2,\r\n        '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n      );\r\n      requestUpdate = true;\r\n    } else if (Object.keys(manifest.modules || {}).length !== numberOfModules) {\r\n      log(\r\n        2,\r\n        '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n      );\r\n      requestUpdate = true;\r\n    } else {\r\n      // Check each module, if anything is missing refetch everything\r\n      requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n        if (!manifest.modules[moduleName]) {\r\n          log(\r\n            2,\r\n            `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n          );\r\n          return true;\r\n        }\r\n      });\r\n    }\r\n\r\n    // Update cache if needed\r\n    if (requestUpdate) {\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n      // Load the sources\r\n      cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n      // Get current modules map\r\n      fetchedModules = manifest.modules;\r\n\r\n      // Extract and save version of currently used Highcharts\r\n      cache.hcVersion = extractVersion(cache.sources);\r\n    }\r\n  }\r\n\r\n  // Finally, save the new manifest, which is basically our current config\r\n  // in a slightly different format\r\n  await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Get the reference to the global options to update to the new version\r\n  const options = getOptions();\r\n\r\n  // Set to the new version\r\n  options.highcharts.version = newVersion;\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is false.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n */\r\nexport async function createChart(options) {\r\n  // Get required functions\r\n  const { getOptions, merge, setOptions, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override userOptions with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in userOptions when forExport is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: options.export.height,\r\n      width: options.export.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${options.export.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${options.export.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(\r\n    `return ${options.export.globalOptions}`\r\n  )();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = options.customLogic.callback\r\n    ? new Function(`return ${options.customLogic.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (options.customLogic.customCode) {\r\n    new Function('options', options.customLogic.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[options.export.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is false.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: join(__dirname, cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, options) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    let isSVG = false;\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await _setAsSvg(page, exportOptions.svg);\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await _setAsOptions(page, options);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, options.customLogic))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the specified page's content with provided export input within\r\n * the window context using the `page.setContent` function.\r\n *\r\n * @async\r\n * @function _setAsSvg\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves after the content is set.\r\n */\r\nasync function _setAsSvg(page, svg) {\r\n  await page.setContent(svgTemplate(svg), {\r\n    waitUntil: 'domcontentloaded'\r\n  });\r\n}\r\n\r\n/**\r\n * Sets the options with specified export input and sizes as configuration into\r\n * the `createChart` function within the window context using\r\n * the `page.evaluate` function.\r\n *\r\n * @async\r\n * @function _setAsOptions\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves after the configuration\r\n * is set.\r\n */\r\nasync function _setAsOptions(page, options) {\r\n  await page.evaluate(createChart, options);\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { getOptions } from './config.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} [poolOptions=getOptions().pool] - Object containing `pool`\r\n * options. The default value is the global pool options of the export server\r\n * instance.\r\n * @param {Array.<string>} [puppeteerArgs=[]] - Additional arguments\r\n * for Puppeteer launch. The default value is an empty array.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(\r\n  poolOptions = getOptions().pool,\r\n  puppeteerArgs = []\r\n) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Kills all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves after the workers are\r\n * killed, the pool is destroyed, and the browser is closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (getOptions().pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          options._requestId\r\n            ? `[benchmark] Request [${options._requestId}] - `\r\n            : '[benchmark] ',\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[pool] ' +\r\n          (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n          `Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Perform an export on a puppeteer level\r\n    const exportCounter = measureTime();\r\n    const result = await puppeteerExport(workerHandle.page, options);\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          '[pool] ' +\r\n            (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n            'Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.'\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          '[pool] ' +\r\n            (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n            `Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        options._requestId\r\n          ? `[benchmark] Request [${options._requestId}] - `\r\n          : '[benchmark] ',\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - Object containing `pool` options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { getOptions, mergeOptions, isAllowedConfig } from './config.js';\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { killPool, postWork, getPoolStats } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\nimport { strictValidate, validateOption } from './validation.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the image in the provided outfile.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain at least one of the following\r\n * properties: `infile`, `instr`, `options`, or `svg` to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Perform an export\r\n    await startExport(options, async (error, data) => {\r\n      // Exit process when error exists\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // Get the `b64`, `outfile`, and `type` for a chart\r\n      const { b64, outfile, type } = data.options.export;\r\n\r\n      // Save the result\r\n      try {\r\n        if (b64) {\r\n          // As a Base64 string to a txt file\r\n          writeFileSync(\r\n            `${outfile.split('.').shift() || 'chart'}.txt`,\r\n            getBase64(data.result, type)\r\n          );\r\n        } else {\r\n          // As a correct image format\r\n          writeFileSync(\r\n            outfile || `chart.${type}`,\r\n            type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n          );\r\n        }\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error while saving a chart.',\r\n          500\r\n        ).setError(error);\r\n      }\r\n\r\n      // Kill pool and close browser after finishing single export\r\n      await killPool();\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on the information\r\n * in the `batch` option. The `batch` is a string in the following format:\r\n * \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results are saved\r\n * in provided outfiles.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain the `batch` option to generate\r\n * valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              ...options,\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              }\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `customOptions` parameter is an object that\r\n * may be partial or complete set of options. The `endCallback` is called when\r\n * the export is completed, with the `error` object as the first argument\r\n * and the `data` object as the second, which contains the Base64 representation\r\n * of the chart in the `result` property and the full set of export options\r\n * in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing work or upon error occurance of the exporting process. The first\r\n * argument is `error` object and the `data` object is the second, that contains\r\n * the Base64 representation of the chart in the `result` property and the full\r\n * set of export options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(customOptions, endCallback) {\r\n  try {\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Merge the custom options into default ones\r\n    const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n    // Get the export options\r\n    const exportOptions = options.export;\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        try {\r\n          // Set to the `svg` option\r\n          exportOptions.svg = validateOption('svg', fileContent, false);\r\n        } catch (error) {\r\n          logZodIssues(\r\n            1,\r\n            error.issues,\r\n            '[config] The `svg` option validation error'\r\n          );\r\n          throw error;\r\n        }\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        try {\r\n          // Set to the `instr` option\r\n          exportOptions.instr = validateOption('instr', fileContent, false);\r\n        } catch (error) {\r\n          logZodIssues(\r\n            1,\r\n            error.issues,\r\n            '[config] The `instr` option validation error'\r\n          );\r\n          throw error;\r\n        }\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // The last strict validation of options right before exporting process\r\n  try {\r\n    // Validate final options\r\n    options = strictValidate(options);\r\n  } catch (error) {\r\n    logZodIssues(1, error.issues, '[config] Final options validation error');\r\n  }\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n *\r\n * @returns {Object} An object containing the calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is null.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  startExport,\r\n  singleExport,\r\n  batchExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} [rateLimitingOptions=getOptions().server.rateLimiting] -\r\n * Object containing `rateLimiting` options. The default value is the global\r\n * rate limiting options of the export server instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(\r\n  app,\r\n  rateLimitingOptions = getOptions().server.rateLimiting\r\n) {\r\n  try {\r\n    // Check if the rate limiting is enabled\r\n    if (rateLimitingOptions.enable) {\r\n      const msg =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        max: rateLimitingOptions.maxRequests || 30,\r\n        window: rateLimitingOptions.window || 1,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || false,\r\n        skipToken: rateLimitingOptions.skipToken || false\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per windowMs\r\n        max: rateOptions.max,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message: msg });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(msg);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== false &&\r\n            rateOptions.skipToken !== false &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.max} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport ExportError from './ExportError.js';\r\n\r\n/**\r\n * A custom HTTP error class that extends the `ExportError`. Used to handle\r\n * errors with HTTP status codes.\r\n */\r\nclass HttpError extends ExportError {\r\n  /**\r\n   * Creates an instance of the `HttpError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super(message, statusCode);\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {HttpError} The updated instance of the `HttpError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default HttpError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n  fixConstr,\r\n  fixType,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new HttpError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the body is not correct.\r\n * @throws {HttpError} Throws an `HttpError` if the chart data from the body\r\n * is not correct.\r\n * @throws {HttpError} Throws an `HttpError` in case of the private range url\r\n * error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid().replace(/-/g, '');\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new HttpError(\r\n        \"[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.\",\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new HttpError(\r\n        \"[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.\",\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new HttpError(\r\n        \"[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.\",\r\n        400\r\n      );\r\n    }\r\n\r\n    try {\r\n      // Validate options from the body and store parsed structure in the request\r\n      request.validatedOptions = looseValidate({\r\n        // Set the created ID as a `_requestId` property in the validated options\r\n        _requestId: requestId,\r\n        export: {\r\n          instr,\r\n          svg: body.svg,\r\n          outfile:\r\n            body.outfile ||\r\n            `${request.params.filename || 'chart'}.${fixType(body.type)}`,\r\n          type: fixType(body.type, body.outfile),\r\n          constr: fixConstr(body.constr),\r\n          b64: body.b64,\r\n          noDownload: body.noDownload,\r\n          height: body.height,\r\n          width: body.width,\r\n          scale: body.scale,\r\n          globalOptions: isAllowedConfig(\r\n            body.globalOptions,\r\n            true,\r\n            allowCodeExecution\r\n          ),\r\n          themeOptions: isAllowedConfig(\r\n            body.themeOptions,\r\n            true,\r\n            allowCodeExecution\r\n          )\r\n        },\r\n        customLogic: {\r\n          allowCodeExecution,\r\n          allowFileResources: false,\r\n          customCode: body.customCode,\r\n          callback: body.callback,\r\n          resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n        }\r\n      });\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[config] Request options validation error'\r\n      );\r\n\r\n      throw new HttpError(\r\n        'The provided options are not correct. Please check if your data is of the correct types.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions._requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Got an incoming HTTP request with ID ${requestId}.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new HttpError(\r\n          '[export] Unexpected return of the export result from the chart generation. Please check your request data.',\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(readFileSync(join(__dirname, 'package.json')));\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new HttpError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new HttpError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      const newVersion = request.params.newVersion;\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new HttpError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new HttpError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { getOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts HTTP or/and HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains all server related properties (see\r\n * the `server` section in the `lib/schemas/config.js` file for a reference).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} [serverOptions=getOptions().server] - Object containing\r\n * `server` options. The default value is the global server options\r\n * of the export server instance.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when the server should not be enabled or when no valid Express app\r\n * is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions = getOptions().server) {\r\n  try {\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    healthRoutes(app);\r\n    exportRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - Object containing `rateLimiting`\r\n * options.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  rateLimitingMiddleware(app, rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Cleans up function to trigger before ending process for the graceful\r\n * shutdown.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} exitCode - An exit code for the `process.exit()` function.\r\n */\r\nexport async function shutdownCleanUp(exitCode) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  setOptions,\r\n  mergeOptions,\r\n  mapToNewOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\nimport server, { startServer } from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage. This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n */\r\nexport async function initExport(customOptions) {\r\n  // Get the global options object copy and extend it with the incoming options\r\n  const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp(0);\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp(0);\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp(0);\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  server,\r\n  startServer,\r\n\r\n  // Options\r\n  getOptions,\r\n  setOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Cache\r\n  checkAndUpdateCache,\r\n\r\n  // Pool\r\n  initPool,\r\n  killPool,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n\r\n  // Utils\r\n  shutdownCleanUp\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","indexOf","object","passthrough","additionalOptions","adminToken","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","isInteger","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","validateOption","name","option","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","_initGlobalOptions","getOptions","getReference","setOptions","customOptions","cliArgs","modifyGlobal","cliOptions","_loadConfigFile","_pairArgumentValue","generalOptions","_updateOptions","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","configOpt","customOpt","cliOpt","configVal","customVal","cliVal","envVal","stringifyFunctions","stringify","replaceAll","Error","configIndex","findIndex","arg","configFileName","i","async","fetch","url","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","ExportError","constructor","statusCode","super","setError","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","customLogicOptions","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","exportOptions","isSVG","_setAsSvg","_setAsOptions","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","_requestId","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","msg","rateOptions","limiter","rateLimit","windowMs","delayMs","handler","format","send","default","skip","query","access_token","HttpError","setStatus","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","limit","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","_attachProcessExitListeners"],"mappings":"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e,CACbtE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEFyD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbvG,KAAM,cACN+G,aAAc,0DAGlBE,iBAAkB,CAChBvE,MAAO,CAAC,kBACRyD,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbvG,KAAM,cACN+G,aAAc,0DAGlBG,cAAe,CACbxE,MAAO,CACL,wEACA,kGAEFyD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbvG,KAAM,OACNwG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN1E,MAAO,KACPyD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbvG,KAAM,SAGVqH,MAAO,CACL3E,MAAO,KACPyD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbvG,KAAM,SAGVsH,QAAS,CACP5E,MAAO,KACPyD,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbvG,KAAM,SAGVuH,IAAK,CACH7E,MAAO,KACPyD,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbvG,KAAM,SAGVwH,MAAO,CACL9E,MAAO,KACPyD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbvG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACPyD,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cA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"} diff --git a/dist/index.esm.js b/dist/index.esm.js index 4d431f23..da49e7bb 100644 --- a/dist/index.esm.js +++ b/dist/index.esm.js @@ -1,2 +1,2 @@ -import"colors";import{readFileSync,existsSync,mkdirSync,appendFile,writeFileSync}from"fs";import{isAbsolute,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import{readFile}from"fs/promises";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return isAbsolute(e)?e:join(__dirname,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:n}=logging;if(5!==t&&(0===t||t>n||n>r.length))return;const i=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t.message,{level:n,levelsDesc:i}=logging;if(0===e||e>n||n>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:n,toFile:i}=e;setLogLevel(t),enableConsoleLogging(n),enableFileLogging(o,r,i)}function setLogLevel(e){e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=e}function enableFileLogging(e,t,o){logging.toFile=o,o&&(logging.dest=e,logging.file=t)}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const n=e[r];void 0===n.value?_createNestedProps(n,t,`${o}.${r}`):(t[n.cliName||r]=`${o}.${r}`.substring(1),void 0!==n.legacyName&&(t[n.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const v={array:e=>z.string().transform((t=>t.split(",").map((e=>e.trim())).filter((t=>e.includes(t))))).transform((e=>e.length?e:void 0)),boolean:()=>z.enum(["true","false",""]).transform((e=>""!==e?"true"===e:void 0)),enum:e=>z.enum([...e,""]).transform((e=>""!==e?e:void 0)),string:()=>z.string().trim().refine((e=>!["false","undefined","null","NaN"].includes(e)||""===e),(e=>({message:`The string contains forbidden values, received '${e}'`}))).transform((e=>""!==e?e:void 0)),positiveNum:()=>z.string().trim().refine((e=>""===e||!isNaN(parseFloat(e))&&parseFloat(e)>0),(e=>({message:`The value must be numeric and positive, received '${e}'`}))).transform((e=>""!==e?parseFloat(e):void 0)),nonNegativeNum:()=>z.string().trim().refine((e=>""===e||!isNaN(parseFloat(e))&&parseFloat(e)>=0),(e=>({message:`The value must be numeric and non-negative, received '${e}'`}))).transform((e=>""!==e?parseFloat(e):void 0))},Config=z.object({PUPPETEER_ARGS:v.string(),HIGHCHARTS_VERSION:z.string().trim().refine((e=>/^(latest|\d+(\.\d+){0,2})$/.test(e)||""===e),(e=>({message:`HIGHCHARTS_VERSION must be 'latest', a major version, or in the form XX.YY.ZZ, received '${e}'`}))).transform((e=>""!==e?e:void 0)),HIGHCHARTS_CDN_URL:z.string().trim().refine((e=>e.startsWith("https://")||e.startsWith("http://")||""===e),(e=>({message:`Invalid value for HIGHCHARTS_CDN_URL. It should start with http:// or https://, received '${e}'`}))).transform((e=>""!==e?e:void 0)),HIGHCHARTS_FORCE_FETCH:v.boolean(),HIGHCHARTS_CACHE_PATH:v.string(),HIGHCHARTS_ADMIN_TOKEN:v.string(),HIGHCHARTS_CORE_SCRIPTS:v.array(defaultConfig.highcharts.coreScripts.value),HIGHCHARTS_MODULE_SCRIPTS:v.array(defaultConfig.highcharts.moduleScripts.value),HIGHCHARTS_INDICATOR_SCRIPTS:v.array(defaultConfig.highcharts.indicatorScripts.value),HIGHCHARTS_CUSTOM_SCRIPTS:v.array(defaultConfig.highcharts.customScripts.value),EXPORT_INFILE:v.string(),EXPORT_INSTR:v.string(),EXPORT_OPTIONS:v.string(),EXPORT_SVG:v.string(),EXPORT_BATCH:v.string(),EXPORT_OUTFILE:v.string(),EXPORT_TYPE:v.enum(["jpeg","png","pdf","svg"]),EXPORT_CONSTR:v.enum(["chart","stockChart","mapChart","ganttChart"]),EXPORT_B64:v.boolean(),EXPORT_NO_DOWNLOAD:v.boolean(),EXPORT_HEIGHT:v.positiveNum(),EXPORT_WIDTH:v.positiveNum(),EXPORT_SCALE:v.positiveNum(),EXPORT_DEFAULT_HEIGHT:v.positiveNum(),EXPORT_DEFAULT_WIDTH:v.positiveNum(),EXPORT_DEFAULT_SCALE:v.positiveNum(),EXPORT_GLOBAL_OPTIONS:v.string(),EXPORT_THEME_OPTIONS:v.string(),EXPORT_RASTERIZATION_TIMEOUT:v.nonNegativeNum(),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:v.boolean(),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:v.boolean(),CUSTOM_LOGIC_CUSTOM_CODE:v.string(),CUSTOM_LOGIC_CALLBACK:v.string(),CUSTOM_LOGIC_RESOURCES:v.string(),CUSTOM_LOGIC_LOAD_CONFIG:v.string(),CUSTOM_LOGIC_CREATE_CONFIG:v.string(),SERVER_ENABLE:v.boolean(),SERVER_HOST:v.string(),SERVER_PORT:v.positiveNum(),SERVER_UPLOAD_LIMIT:v.positiveNum(),SERVER_BENCHMARKING:v.boolean(),SERVER_PROXY_HOST:v.string(),SERVER_PROXY_PORT:v.positiveNum(),SERVER_PROXY_TIMEOUT:v.nonNegativeNum(),SERVER_RATE_LIMITING_ENABLE:v.boolean(),SERVER_RATE_LIMITING_MAX_REQUESTS:v.nonNegativeNum(),SERVER_RATE_LIMITING_WINDOW:v.nonNegativeNum(),SERVER_RATE_LIMITING_DELAY:v.nonNegativeNum(),SERVER_RATE_LIMITING_TRUST_PROXY:v.boolean(),SERVER_RATE_LIMITING_SKIP_KEY:v.string(),SERVER_RATE_LIMITING_SKIP_TOKEN:v.string(),SERVER_SSL_ENABLE:v.boolean(),SERVER_SSL_FORCE:v.boolean(),SERVER_SSL_PORT:v.positiveNum(),SERVER_SSL_CERT_PATH:v.string(),POOL_MIN_WORKERS:v.nonNegativeNum(),POOL_MAX_WORKERS:v.nonNegativeNum(),POOL_WORK_LIMIT:v.positiveNum(),POOL_ACQUIRE_TIMEOUT:v.nonNegativeNum(),POOL_CREATE_TIMEOUT:v.nonNegativeNum(),POOL_DESTROY_TIMEOUT:v.nonNegativeNum(),POOL_IDLE_TIMEOUT:v.nonNegativeNum(),POOL_CREATE_RETRY_INTERVAL:v.nonNegativeNum(),POOL_REAPER_INTERVAL:v.nonNegativeNum(),POOL_BENCHMARKING:v.boolean(),LOGGING_LEVEL:z.string().trim().refine((e=>""===e||!isNaN(parseFloat(e))&&parseFloat(e)>=0&&parseFloat(e)<=5),(e=>({message:`Invalid value for LOGGING_LEVEL. We only accept values from 0 to 5 as logging levels, received '${e}'`}))).transform((e=>""!==e?parseFloat(e):void 0)),LOGGING_FILE:v.string(),LOGGING_DEST:v.string(),LOGGING_TO_CONSOLE:v.boolean(),LOGGING_TO_FILE:v.boolean(),UI_ENABLE:v.boolean(),UI_ROUTE:v.string(),OTHER_NODE_ENV:v.enum(["development","production","test"]),OTHER_LISTEN_TO_PROCESS_EXITS:v.boolean(),OTHER_NO_LOGO:v.boolean(),OTHER_HARD_RESET_PAGE:v.boolean(),OTHER_BROWSER_SHELL_MODE:v.boolean(),DEBUG_ENABLE:v.boolean(),DEBUG_HEADLESS:v.boolean(),DEBUG_DEVTOOLS:v.boolean(),DEBUG_LISTEN_TO_CONSOLE:v.boolean(),DEBUG_DUMPIO:v.boolean(),DEBUG_SLOW_MO:v.nonNegativeNum(),DEBUG_DEBUGGING_PORT:v.positiveNum()}),envs=Config.partial().parse(process.env),globalOptions=_initGlobalOptions(defaultConfig);function getOptions(e=!0){return e?globalOptions:deepCopy(globalOptions)}function setOptions(e={},t=[],o=!1){let r={},n={};t.length&&(r=_loadConfigFile(t),n=_pairArgumentValue(nestedProps,t));const i=getOptions(o);return _updateOptions(defaultConfig,i,r,e,n),i}function mergeOptions(e,t){if(isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],r):void 0!==r?r:e[o];return e}function mapToNewOptions(e){const t={};if("[object Object]"===Object.prototype.toString.call(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,n)=>t[o]=e.length-1===n?r:t[o]||{}),t)}return t}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,r]of Object.entries(e))t[o]=Object.prototype.hasOwnProperty.call(r,"value")?r.value:_initGlobalOptions(r);return t}function _updateOptions(e,t,o,r,n){Object.keys(e).forEach((i=>{const s=e[i],a=o&&o[i],l=r&&r[i],c=n&&n[i];if(void 0===s.value)_updateOptions(s,t[i],a,l,c);else{null!=a&&(t[i]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[i]=e),null!=l&&(t[i]=l),null!=c&&(t[i]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e){const t=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),o=t>-1&&e[t+1];if(o)try{return JSON.parse(readFileSync(getAbsolutePath(o)))}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${o} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let r=0;r{if(i.length-1===s){const i=t[++r];i||log(2,`[config] Missing value for the CLI '--${n}' argument. Using the default value.`),e[o]=i||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){let o;const r=getCachePath(),n=join(r,"manifest.json"),i=join(r,"sources.js");if(!existsSync(r)&&mkdirSync(r,{recursive:!0}),!existsSync(n)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let r=!1;const s=JSON.parse(readFileSync(n));if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const n=await fetch(`${e}.js`,t);if(200===n.statusCode&&"string"==typeof n.text){if(o){o[extractModuleName(e)]=1}return n.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${n.statusCode}).`,404).setError(n);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,n){let i;const s=r.host,a=r.port;if(s&&a)try{i=new HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,n,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,n))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,n=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${n}/${r}/${e}`:`${n}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${n}/maps/${r}/modules/${e}`:`${n}/maps/modules/${e}`:r?`${n}/${r}/modules/${e}`:`${n}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${n}/stock/${r}/indicators/${e}`:`${n}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e){const{getOptions:t,merge:o,setOptions:r,wrap:n}=Highcharts;Highcharts.setOptionsObj=o(!1,{},t()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,r){((t=o(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,r])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const i={chart:{animation:!1,height:e.export.height,width:e.export.width},exporting:{enabled:!1}},s=new Function(`return ${e.export.instr}`)(),a=new Function(`return ${e.export.themeOptions}`)(),l=new Function(`return ${e.export.globalOptions}`)(),c=o(!1,a,s,i),p=e.customLogic.callback?new Function(`return ${e.customLogic.callback}`)():null;e.customLogic.customCode&&new Function("options",e.customLogic.customCode)(s),l&&r(l),Highcharts[e.export.constr]("container",c,p);const u=t();for(const e in u)"function"!=typeof u[e]&&delete u[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...n}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&n};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const n=[];if(r.js&&n.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");n.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of n)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}n.length=0;const i=[];if(r.css){let n=r.css.match(/@import\s*([^;]*);/g);if(n)for(let e of n)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:join(__dirname,e)}));i.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t){const o=[];try{const r=t.export;let n=!1;if(r.svg){if(log(4,"[export] Treating as SVG input."),"svg"===r.type)return r.svg;n=!0,await _setAsSvg(e,r.svg)}else log(4,"[export] Treating as JSON config."),await _setAsOptions(e,t);o.push(...await addPageResources(e,t.customLogic));const i=n?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(r.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||r.height)),c=Math.abs(Math.ceil(i.chartWidth||r.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:n?1:parseFloat(r.scale)}),r.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,r.type,{width:c,height:l,x:s,y:a},r.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,r.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${r.type}.`,400)}return await clearPageResources(e,o),p}catch(t){return await clearPageResources(e,o),t}}async function _setAsSvg(e,t){await e.setContent(svgTemplate(t),{waitUntil:"domcontentloaded"})}async function _setAsOptions(e,t){await e.evaluate(createChart,t)}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:n}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(n>1?n:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e=getOptions().pool,t=[]){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,getOptions().pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const n=measureTime(),i=await puppeteerExport(t.page,e);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+"Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.").setError(i):new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered during export: ${n()}ms.`).setError(i);e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Exporting a chart sucessfully took ${n()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:n,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${n}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport(e,(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):writeFileSync(r||`chart.${n}`,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({...e,export:{...e.export,infile:o[0],outfile:o[1]}},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):writeFileSync(r,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{log(4,"[chart] Starting the exporting process.");const o=mergeOptions(getOptions(!1),e),r=o.export;if(null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=e;else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=e}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:n}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||n?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||n?.sourceHeight||r?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||n?.sourceWidth||r?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let n=e,i=!1;if(t&&e.endsWith(".json"))try{n=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else n=isAllowedConfig(e,!1,o),n&&!t&&delete n.files;for(const e in n)r.includes(e)?i||(i=!0):delete n[e];return i?(n.files&&(n.files=n.files.map((e=>e.trim())),(!n.files||n.files.length<=0)&&delete n.files),n):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:n,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:n,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t=getOptions().server.rateLimiting){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={max:t.maxRequests||30,window:t.window||1,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||!1,skipToken:t.skipToken||!1};r.trustProxy&&e.enable("trust proxy");const n=rateLimit({windowMs:60*r.window*1e3,max:r.max,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>!1!==r.skipKey&&!1!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(n),log(3,`[rate limiting] Enabled rate limiting with ${r.max} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}class HttpError extends ExportError{constructor(e,t){super(e,t)}setStatus(e){return this.statusCode=e,this}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new HttpError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=v4().replace(/-/g,"");if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new HttpError("[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.",400);const n=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,n);if(null===i&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new HttpError("[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.",400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new HttpError("[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.",400);return e.validatedOptions={_requestId:r,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${fixType(t.type)}`,type:fixType(t.type,t.outfile),constr:fixConstr(t.constr),b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,n),themeOptions:isAllowedConfig(t.themeOptions,!0,n)},customLogic:{allowCodeExecution:n,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,n)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const n=e.validatedOptions,i=n._requestId;log(4,`[export] Got an incoming HTTP request with ID ${i}.`),await startExport(n,((n,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(n)throw n;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new HttpError("[export] Unexpected return of the export result from the chart generation. Please check your request data.",400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:n,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),n||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"))),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new HttpError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new HttpError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const n=e.params.newVersion;if(!n)throw new HttpError("[version] No new version supplied.",400);try{await updateHighchartsVersion(n)}catch(e){throw new HttpError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${n}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e=getOptions().server){try{if(!e.enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const t=1024*e.uploadLimit*1024,o=multer.memoryStorage(),r=multer({storage:o,limits:{fieldSize:t}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:t})),app.use(express.urlencoded({extended:!0,limit:t})),app.use(r.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),healthRoutes(app),exportRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){rateLimitingMiddleware(app,e)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=mergeOptions(getOptions(!1),e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={server:server,startServer:startServer,getOptions:getOptions,setOptions:setOptions,mergeOptions:mergeOptions,mapToNewOptions:mapToNewOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,checkAndUpdateCache:checkAndUpdateCache,initPool:initPool,killPool:killPool,log:log,logWithStack:logWithStack,setLogLevel:setLogLevel,enableConsoleLogging:enableConsoleLogging,enableFileLogging:enableFileLogging,shutdownCleanUp:shutdownCleanUp};export{index as default,initExport}; +import"colors";import{readFileSync,existsSync,mkdirSync,appendFile,writeFileSync}from"fs";import{isAbsolute,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import{readFile}from"fs/promises";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},n=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":n.includes(o)&&e!==o&&(e=o)}return o[e]||n.find((t=>t===e))||"png"}function getAbsolutePath(e){return isAbsolute(e)?e:join(__dirname,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:n,level:r}=logging;if(5!==t&&(0===t||t>r||r>n.length))return;const i=`${getNewDate()} [${n[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const n=o||t.message,{level:r,levelsDesc:i}=logging;if(0===e||e>r||r>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t.stack,l=[n];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t=[],o){logWithStack(e,null,[`${o} - the following Zod issues occured:`,...t.map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:n,toConsole:r,toFile:i}=e;setLogLevel(t),enableConsoleLogging(r),enableFileLogging(o,n,i)}function setLogLevel(e){e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=e}function enableFileLogging(e,t,o){logging.toFile=o,o&&(logging.dest=e,logging.file=t)}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((n=>{const r=e[n];void 0===r.value?_createNestedProps(r,t,`${o}.${n}`):(t[r.cliName||n]=`${o}.${n}`.substring(1),void 0!==r.legacyName&&(t[r.legacyName]=`${o}.${n}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const n=e[o];void 0===n.types?_createAbsoluteProps(n,t):n.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","false","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const n=z.string().trim().array(),r=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?n.transform(i):z.union([r,n]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},config={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),n=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json'"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,n]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json "}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with '.log'"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:config.args(e)}).partial(),HighchartsSchema=e=>z.object({version:config.version(e),cdnUrl:config.cdnUrl(e),forceFetch:config.forceFetch(e),cachePath:config.cachePath(e),coreScripts:config.coreScripts(e),moduleScripts:config.moduleScripts(e),indicatorScripts:config.indicatorScripts(e),customScripts:config.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:config.infile(e),instr:config.instr(),options:config.options(),svg:config.svg(),outfile:config.outfile(e),type:config.type(e),constr:config.constr(e),b64:config.b64(e),noDownload:config.noDownload(e),defaultHeight:config.defaultHeight(e),defaultWidth:config.defaultWidth(e),defaultScale:config.defaultScale(e),height:config.height(e),width:config.width(e),scale:config.scale(e),globalOptions:config.globalOptions(),themeOptions:config.themeOptions(),batch:config.batch(!1),rasterizationTimeout:config.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:config.allowCodeExecution(e),allowFileResources:config.allowFileResources(e),customCode:config.customCode(!1),callback:config.callback(!1),resources:config.resources(e),loadConfig:config.loadConfig(!1),createConfig:config.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:config.proxyHost(!1),port:config.proxyPort(e),timeout:config.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:config.enableRateLimiting(e),maxRequests:config.maxRequests(e),window:config.window(e),delay:config.delay(e),trustProxy:config.trustProxy(e),skipKey:config.skipKey(!1),skipToken:config.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:config.enableSsl(e),force:config.sslForce(e),port:config.sslPort(e),certPath:config.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:config.enableServer(e).optional(),host:config.host(e).optional(),port:config.port(e).optional(),benchmarking:config.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:config.minWorkers(e),maxWorkers:config.maxWorkers(e),workLimit:config.workLimit(e),acquireTimeout:config.acquireTimeout(e),createTimeout:config.createTimeout(e),destroyTimeout:config.destroyTimeout(e),idleTimeout:config.idleTimeout(e),createRetryInterval:config.createRetryInterval(e),reaperInterval:config.reaperInterval(e),benchmarking:config.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:config.logLevel(e),file:config.logFile(e),dest:config.logDest(e),toConsole:config.logToConsole(e),toFile:config.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:config.enableUi(e),route:config.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:config.nodeEnv(e),listenToProcessExits:config.listenToProcessExits(e),noLogo:config.noLogo(e),hardResetPage:config.hardResetPage(e),browserShellMode:config.browserShellMode(e)}).partial(),DebugSchema=e=>z.object({enable:config.enableDebug(e),headless:config.headless(e),devtools:config.devtools(e),listenToConsole:config.listenToConsole(e),dumpio:config.dumpio(e),slowMo:config.slowMo(e),debuggingPort:config.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:config.args(!1),HIGHCHARTS_VERSION:config.version(!1),HIGHCHARTS_CDN_URL:config.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:config.forceFetch(!1),HIGHCHARTS_CACHE_PATH:config.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:config.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:config.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:config.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:config.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:config.customScripts(!1),EXPORT_INFILE:config.infile(!1),EXPORT_INSTR:config.instr(),EXPORT_OPTIONS:config.options(),EXPORT_SVG:config.svg(),EXPORT_BATCH:config.batch(!1),EXPORT_OUTFILE:config.outfile(!1),EXPORT_TYPE:config.type(!1),EXPORT_CONSTR:config.constr(!1),EXPORT_B64:config.b64(!1),EXPORT_NO_DOWNLOAD:config.noDownload(!1),EXPORT_HEIGHT:config.height(!1),EXPORT_WIDTH:config.width(!1),EXPORT_SCALE:config.scale(!1),EXPORT_DEFAULT_HEIGHT:config.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:config.defaultWidth(!1),EXPORT_DEFAULT_SCALE:config.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:config.globalOptions(),EXPORT_THEME_OPTIONS:config.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:config.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:config.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:config.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:config.customCode(!1),CUSTOM_LOGIC_CALLBACK:config.callback(!1),CUSTOM_LOGIC_RESOURCES:config.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:config.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:config.createConfig(!1),SERVER_ENABLE:config.enableServer(!1),SERVER_HOST:config.host(!1),SERVER_PORT:config.port(!1),SERVER_UPLOAD_LIMIT:config.uploadLimit(!1),SERVER_BENCHMARKING:config.serverBenchmarking(!1),SERVER_PROXY_HOST:config.proxyHost(!1),SERVER_PROXY_PORT:config.proxyPort(!1),SERVER_PROXY_TIMEOUT:config.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:config.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:config.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:config.window(!1),SERVER_RATE_LIMITING_DELAY:config.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:config.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:config.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:config.skipToken(!1),SERVER_SSL_ENABLE:config.enableSsl(!1),SERVER_SSL_FORCE:config.sslForce(!1),SERVER_SSL_PORT:config.sslPort(!1),SERVER_SSL_CERT_PATH:config.sslCertPath(!1),POOL_MIN_WORKERS:config.minWorkers(!1),POOL_MAX_WORKERS:config.maxWorkers(!1),POOL_WORK_LIMIT:config.workLimit(!1),POOL_ACQUIRE_TIMEOUT:config.acquireTimeout(!1),POOL_CREATE_TIMEOUT:config.createTimeout(!1),POOL_DESTROY_TIMEOUT:config.destroyTimeout(!1),POOL_IDLE_TIMEOUT:config.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:config.createRetryInterval(!1),POOL_REAPER_INTERVAL:config.reaperInterval(!1),POOL_BENCHMARKING:config.poolBenchmarking(!1),LOGGING_LEVEL:config.logLevel(!1),LOGGING_FILE:config.logFile(!1),LOGGING_DEST:config.logDest(!1),LOGGING_TO_CONSOLE:config.logToConsole(!1),LOGGING_TO_FILE:config.logToFile(!1),UI_ENABLE:config.enableUi(!1),UI_ROUTE:config.uiRoute(!1),OTHER_NODE_ENV:config.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:config.listenToProcessExits(!1),OTHER_NO_LOGO:config.noLogo(!1),OTHER_HARD_RESET_PAGE:config.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:config.browserShellMode(!1),DEBUG_ENABLE:config.enableDebug(!1),DEBUG_HEADLESS:config.headless(!1),DEBUG_DEVTOOLS:config.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:config.listenToConsole(!1),DEBUG_DUMPIO:config.dumpio(!1),DEBUG_SLOW_MO:config.slowMo(!1),DEBUG_DEBUGGING_PORT:config.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function validateOption(e,t,o){return config[e](o).parse(t)}function _customErrorMap(e,t){const o=e.path.join("."),n=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${n} - No value was provided.`}:{message:`${n} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${n} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${n} - ${t.defaultError}.`}}const globalOptions=_initGlobalOptions(defaultConfig);function getOptions(e=!0){return e?globalOptions:deepCopy(globalOptions)}function setOptions(e={},t=[],o=!1){let n={},r={};if(t.length)try{n=strictValidate(_loadConfigFile(t))}catch(e){logZodIssues(1,e.issues,"[config] Custom JSON options validation error")}if(e&&0!==Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Custom options validation error")}if(t.length)try{r=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[config] CLI options validation error")}const i=getOptions(o);return _updateOptions(defaultConfig,i,n,e,r),i}function mergeOptions(e,t){if(isObject(t))for(const[o,n]of Object.entries(t))e[o]=isObject(n)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],n):void 0!==n?n:e[o];return e}function mapToNewOptions(e){const t={};if("[object Object]"===Object.prototype.toString.call(e))for(const[o,n]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,r)=>t[o]=e.length-1===r?n:t[o]||{}),t)}return t}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,n]of Object.entries(e))t[o]=Object.prototype.hasOwnProperty.call(n,"value")?n.value:_initGlobalOptions(n);return t}function _updateOptions(e,t,o,n,r){Object.keys(e).forEach((i=>{const s=e[i],a=o&&o[i],l=n&&n[i],c=r&&r[i];if(void 0===s.value)_updateOptions(s,t[i],a,l,c);else{null!=a&&(t[i]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[i]=e),null!=l&&(t[i]=l),null!=c&&(t[i]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,n)=>{if("string"==typeof n&&(n=n.trim()),"function"==typeof n||"string"==typeof n&&n.startsWith("function")&&n.endsWith("}")){if(t)return o?`"EXP_FUN${(n+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(n+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return n})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e){const t=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),o=t>-1&&e[t+1];if(o)try{return JSON.parse(readFileSync(getAbsolutePath(o)))}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${o} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let n=0;n{if(i.length-1===s){const i=t[++n];i||log(2,`[config] Missing value for the CLI '--${r}' argument. Using the default value.`),e[o]=i||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,n)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||n("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{n(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){let o;const n=getCachePath(),r=join(n,"manifest.json"),i=join(n,"sources.js");if(!existsSync(n)&&mkdirSync(n,{recursive:!0}),!existsSync(r)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let n=!1;const s=JSON.parse(readFileSync(r));if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),n=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),n=!0):n=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),n?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,n=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const r=await fetch(`${e}.js`,t);if(200===r.statusCode&&"string"==typeof r.text){if(o){o[extractModuleName(e)]=1}return r.text}if(n)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${r.statusCode}).`,404).setError(r);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,n,r){let i;const s=n.host,a=n.port;if(s&&a)try{i=new HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:n.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,r,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,r))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const n="latest"===e.version?null:`${e.version}`,r=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${n||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>n?`${r}/${n}/${e}`:`${r}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?n?`${r}/maps/${n}/modules/${e}`:`${r}/maps/modules/${e}`:n?`${r}/${n}/modules/${e}`:`${r}/modules/${e}`)),...e.indicatorScripts.map((e=>n?`${r}/stock/${n}/indicators/${e}`:`${r}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e){const{getOptions:t,merge:o,setOptions:n,wrap:r}=Highcharts;Highcharts.setOptionsObj=o(!1,{},t()),window.isRenderComplete=!1,r(Highcharts.Chart.prototype,"init",(function(e,t,n){((t=o(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,n])})),r(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const i={chart:{animation:!1,height:e.export.height,width:e.export.width},exporting:{enabled:!1}},s=new Function(`return ${e.export.instr}`)(),a=new Function(`return ${e.export.themeOptions}`)(),l=new Function(`return ${e.export.globalOptions}`)(),c=o(!1,a,s,i),p=e.customLogic.callback?new Function(`return ${e.customLogic.callback}`)():null;e.customLogic.customCode&&new Function("options",e.customLogic.customCode)(s),l&&n(l),Highcharts[e.export.constr]("container",c,p);const u=t();for(const e in u)"function"!=typeof u[e]&&delete u[e];n(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:n,...r}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...n&&r};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),n&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],n=t.resources;if(n){const r=[];if(n.js&&r.push({content:n.js}),n.files)for(const e of n.files){const t=!e.startsWith("http");r.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of r)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}r.length=0;const i=[];if(n.css){let r=n.css.match(/@import\s*([^;]*);/g);if(r)for(let e of r)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:join(__dirname,e)}));i.push({content:n.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const n of[...e,...t,...o])n.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t){const o=[];try{const n=t.export;let r=!1;if(n.svg){if(log(4,"[export] Treating as SVG input."),"svg"===n.type)return n.svg;r=!0,await _setAsSvg(e,n.svg)}else log(4,"[export] Treating as JSON config."),await _setAsOptions(e,t);o.push(...await addPageResources(e,t.customLogic));const i=r?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,n=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:n}}),parseFloat(n.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||n.height)),c=Math.abs(Math.ceil(i.chartWidth||n.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:r?1:parseFloat(n.scale)}),n.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,n.type,{width:c,height:l,x:s,y:a},n.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,n.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${n.type}.`,400)}return await clearPageResources(e,o),p}catch(t){return await clearPageResources(e,o),t}}async function _setAsSvg(e,t){await e.setContent(svgTemplate(t),{waitUntil:"domcontentloaded"})}async function _setAsOptions(e,t){await e.evaluate(createChart,t)}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:n,height:r}=e.getBoundingClientRect();return{x:t,y:o,width:n,height:Math.trunc(r>1?r:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,n){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),n||1500)))])}async function _createPDF(e,t,o,n){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:n||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e=getOptions().pool,t=[]){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,getOptions().pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const n=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),i=await puppeteerExport(t.page,e);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+"Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.").setError(i):new ExportError("[pool] "+(e._requestId?`Request [${e._requestId}] - `:"")+`Error encountered during export: ${r()}ms.`).setError(i);e.server.benchmarking&&log(5,e._requestId?`[benchmark] Request [${e._requestId}] - `:"[benchmark] ",`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t);const s=getNewDateTime()-n;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:n,allCreated:r,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${n}.`),log(5,`[pool] The number of all created (used and free) resources: ${r}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport(e,(async(e,t)=>{if(e)throw e;const{b64:o,outfile:n,type:r}=t.options.export;try{o?writeFileSync(`${n.split(".").shift()||"chart"}.txt`,getBase64(t.result,r)):writeFileSync(n||`chart.${r}`,"svg"!==r?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({...e,export:{...e.export,infile:o[0],outfile:o[1]}},((e,t)=>{if(e)throw e;const{b64:o,outfile:n,type:r}=t.options.export;try{o?writeFileSync(`${n.split(".").shift()||"chart"}.txt`,getBase64(t.result,r)):writeFileSync(n,"svg"!==r?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{log(4,"[chart] Starting the exporting process.");const o=mergeOptions(getOptions(!1),e),n=o.export;if(null!==n.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(n.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(n.infile.endsWith(".svg"))try{n.svg=validateOption("svg",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `svg` option validation error"),e}else{if(!n.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);try{n.instr=validateOption("instr",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `instr` option validation error"),e}}}if(null!==n.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(n.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==n.instr||null!==n.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(n.instr||n.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)};try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Final options validation error")}return postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:n,exporting:r}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||r?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||r?.sourceHeight||n?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||r?.sourceWidth||n?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const n=["js","css","files"];let r=e,i=!1;if(t&&e.endsWith(".json"))try{r=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files;for(const e in r)n.includes(e)?i||(i=!0):delete r[e];return i?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((n=>{try{e[n]&&(t&&"string"==typeof e[n]&&e[n].endsWith(".json")?e[n]=isAllowedConfig(readFileSync(getAbsolutePath(e[n]),"utf8"),!0,o):e[n]=isAllowedConfig(e[n],!0,o))}catch(t){logWithStack(2,t,`[chart] The \`${n}\` cannot be loaded.`),e[n]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,n){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,n(e)}function returnErrorMiddleware(e,t,o,n){const{message:r,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:r,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t=getOptions().server.rateLimiting){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",n={max:t.maxRequests||30,window:t.window||1,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||!1,skipToken:t.skipToken||!1};n.trustProxy&&e.enable("trust proxy");const r=rateLimit({windowMs:60*n.window*1e3,max:n.max,delayMs:n.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>!1!==n.skipKey&&!1!==n.skipToken&&e.query.key===n.skipKey&&e.query.access_token===n.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(r),log(3,`[rate limiting] Enabled rate limiting with ${n.max} requests per ${n.window} minute for each IP, trusting proxy: ${n.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}class HttpError extends ExportError{constructor(e,t){super(e,t)}setStatus(e){return this.statusCode=e,this}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new HttpError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,n=v4().replace(/-/g,"");if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${n}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new HttpError("[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.",400);const r=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,r);if(null===i&&!t.svg)throw log(2,`[validation] Request [${n}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new HttpError("[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.",400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new HttpError("[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.",400);try{e.validatedOptions=looseValidate({_requestId:n,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${fixType(t.type)}`,type:fixType(t.type,t.outfile),constr:fixConstr(t.constr),b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,r),themeOptions:isAllowedConfig(t.themeOptions,!0,r)},customLogic:{allowCodeExecution:r,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,r)}})}catch(e){throw logZodIssues(1,e.issues,"[config] Request options validation error"),new HttpError("The provided options are not correct. Please check if your data is of the correct types.",400)}return o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let n=!1;e.socket.on("close",(e=>{e&&(n=!0)}));const r=e.validatedOptions,i=r._requestId;log(4,`[export] Got an incoming HTTP request with ID ${i}.`),await startExport(r,((r,s)=>{if(e.socket.removeAllListeners("close"),n)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(r)throw r;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new HttpError("[export] Unexpected return of the export result from the chart generation. Please check your request data.",400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:n,noDownload:r,outfile:a}=s.options.export;return n?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),r||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"))),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,n=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:n,message:isNaN(n)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${n.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new HttpError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const n=e.get("hc-auth");if(!n||n!==o)throw new HttpError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const r=e.params.newVersion;if(!r)throw new HttpError("[version] No new version supplied.",400);try{await updateHighchartsVersion(r)}catch(e){throw new HttpError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${r}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e=getOptions().server){try{if(!e.enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const t=1024*e.uploadLimit*1024,o=multer.memoryStorage(),n=multer({storage:o,limits:{fieldSize:t}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:t})),app.use(express.urlencoded({extended:!0,limit:t})),app.use(n.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const n=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(n),n.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,n),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),healthRoutes(app),exportRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){rateLimitingMiddleware(app,e)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=mergeOptions(getOptions(!1),e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp(0)})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={server:server,startServer:startServer,getOptions:getOptions,setOptions:setOptions,mergeOptions:mergeOptions,mapToNewOptions:mapToNewOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,checkAndUpdateCache:checkAndUpdateCache,initPool:initPool,killPool:killPool,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:setLogLevel,enableConsoleLogging:enableConsoleLogging,enableFileLogging:enableFileLogging,shutdownCleanUp:shutdownCleanUp};export{index as default,initExport}; //# sourceMappingURL=index.esm.js.map diff --git a/dist/index.esm.js.map b/dist/index.esm.js.map index 6ba656dd..75408356 100644 --- a/dist/index.esm.js.map +++ b/dist/index.esm.js.map @@ -1 +1 @@ -{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/envs.js","../lib/config.js","../lib/fetch.js","../lib/errors/ExportError.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/errors/HttpError.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is 0.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is null.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message. Accepts a variable amount of arguments. Arguments after\r\n * the `level` will be passed directly to `console.log`, and/or will be joined\r\n * and appended to the log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the rest are strings to build a message with.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || error.message;\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - Object containing `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (0 = no logging,\r\n * 1 = error, 2 = warning, 3 = notice, 4 = verbose, or 5 = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (level >= 0 && level <= logging.levelsDesc.length) {\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update options for the console logging\r\n logging.toConsole = toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path for the log file.\r\n * @param {string} file - The log file name.\r\n * @param {boolean} toFile - The flag for setting the logging to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update options for the file logging\r\n logging.toFile = toFile;\r\n\r\n // Set the `dest` and `file` only if the file logging is enabled\r\n if (toFile) {\r\n logging.dest = dest;\r\n logging.file = file;\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file is responsible for parsing the environment variables\r\n * with the 'zod' library. The parsed environment variables are then exported\r\n * to be used in the application as `envs`. We should not use the `process.env`\r\n * directly in the application as these would not be parsed properly.\r\n *\r\n * The environment variables are parsed and validated only once when\r\n * the application starts. We should write a custom validator or a transformer\r\n * for each of the options.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load .env into environment variables\r\ndotenv.config();\r\n\r\n// Object with custom validators and transformers, to avoid repetition\r\n// in the Config object\r\nconst v = {\r\n // Splits string value into elements in an array, trims every element, checks\r\n // if an array is correct, if it is empty, and if it is, returns undefined\r\n array: (filterArray) =>\r\n z\r\n .string()\r\n .transform((value) =>\r\n value\r\n .split(',')\r\n .map((value) => value.trim())\r\n .filter((value) => filterArray.includes(value))\r\n )\r\n .transform((value) => (value.length ? value : undefined)),\r\n\r\n // Allows only true, false and correctly parse the value to boolean\r\n // or no value in which case the returned value will be undefined\r\n boolean: () =>\r\n z\r\n .enum(['true', 'false', ''])\r\n .transform((value) => (value !== '' ? value === 'true' : undefined)),\r\n\r\n // Allows passed values or no value in which case the returned value will\r\n // be undefined\r\n enum: (values) =>\r\n z\r\n .enum([...values, ''])\r\n .transform((value) => (value !== '' ? value : undefined)),\r\n\r\n // Trims the string value and checks if it is empty or contains stringified\r\n // values such as false, undefined, null, NaN, if it does, returns undefined\r\n string: () =>\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n !['false', 'undefined', 'null', 'NaN'].includes(value) ||\r\n value === '',\r\n (value) => ({\r\n message: `The string contains forbidden values, received '${value}'`\r\n })\r\n )\r\n .transform((value) => (value !== '' ? value : undefined)),\r\n\r\n // Allows positive numbers or no value in which case the returned value will\r\n // be undefined\r\n positiveNum: () =>\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n value === '' || (!isNaN(parseFloat(value)) && parseFloat(value) > 0),\r\n (value) => ({\r\n message: `The value must be numeric and positive, received '${value}'`\r\n })\r\n )\r\n .transform((value) => (value !== '' ? parseFloat(value) : undefined)),\r\n\r\n // Allows non-negative numbers or no value in which case the returned value\r\n // will be undefined\r\n nonNegativeNum: () =>\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n value === '' || (!isNaN(parseFloat(value)) && parseFloat(value) >= 0),\r\n (value) => ({\r\n message: `The value must be numeric and non-negative, received '${value}'`\r\n })\r\n )\r\n .transform((value) => (value !== '' ? parseFloat(value) : undefined))\r\n};\r\n\r\nexport const Config = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: v.string(),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => /^(latest|\\d+(\\.\\d+){0,2})$/.test(value) || value === '',\r\n (value) => ({\r\n message: `HIGHCHARTS_VERSION must be 'latest', a major version, or in the form XX.YY.ZZ, received '${value}'`\r\n })\r\n )\r\n .transform((value) => (value !== '' ? value : undefined)),\r\n HIGHCHARTS_CDN_URL: z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n value.startsWith('https://') ||\r\n value.startsWith('http://') ||\r\n value === '',\r\n (value) => ({\r\n message: `Invalid value for HIGHCHARTS_CDN_URL. It should start with http:// or https://, received '${value}'`\r\n })\r\n )\r\n .transform((value) => (value !== '' ? value : undefined)),\r\n HIGHCHARTS_FORCE_FETCH: v.boolean(),\r\n HIGHCHARTS_CACHE_PATH: v.string(),\r\n HIGHCHARTS_ADMIN_TOKEN: v.string(),\r\n HIGHCHARTS_CORE_SCRIPTS: v.array(defaultConfig.highcharts.coreScripts.value),\r\n HIGHCHARTS_MODULE_SCRIPTS: v.array(\r\n defaultConfig.highcharts.moduleScripts.value\r\n ),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: v.array(\r\n defaultConfig.highcharts.indicatorScripts.value\r\n ),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: v.array(\r\n defaultConfig.highcharts.customScripts.value\r\n ),\r\n\r\n // export\r\n EXPORT_INFILE: v.string(),\r\n EXPORT_INSTR: v.string(),\r\n EXPORT_OPTIONS: v.string(),\r\n EXPORT_SVG: v.string(),\r\n EXPORT_BATCH: v.string(),\r\n EXPORT_OUTFILE: v.string(),\r\n EXPORT_TYPE: v.enum(['jpeg', 'png', 'pdf', 'svg']),\r\n EXPORT_CONSTR: v.enum(['chart', 'stockChart', 'mapChart', 'ganttChart']),\r\n EXPORT_B64: v.boolean(),\r\n EXPORT_NO_DOWNLOAD: v.boolean(),\r\n EXPORT_HEIGHT: v.positiveNum(),\r\n EXPORT_WIDTH: v.positiveNum(),\r\n EXPORT_SCALE: v.positiveNum(),\r\n EXPORT_DEFAULT_HEIGHT: v.positiveNum(),\r\n EXPORT_DEFAULT_WIDTH: v.positiveNum(),\r\n EXPORT_DEFAULT_SCALE: v.positiveNum(),\r\n EXPORT_GLOBAL_OPTIONS: v.string(),\r\n EXPORT_THEME_OPTIONS: v.string(),\r\n EXPORT_RASTERIZATION_TIMEOUT: v.nonNegativeNum(),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: v.boolean(),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: v.boolean(),\r\n CUSTOM_LOGIC_CUSTOM_CODE: v.string(),\r\n CUSTOM_LOGIC_CALLBACK: v.string(),\r\n CUSTOM_LOGIC_RESOURCES: v.string(),\r\n CUSTOM_LOGIC_LOAD_CONFIG: v.string(),\r\n CUSTOM_LOGIC_CREATE_CONFIG: v.string(),\r\n\r\n // server\r\n SERVER_ENABLE: v.boolean(),\r\n SERVER_HOST: v.string(),\r\n SERVER_PORT: v.positiveNum(),\r\n SERVER_UPLOAD_LIMIT: v.positiveNum(),\r\n SERVER_BENCHMARKING: v.boolean(),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: v.string(),\r\n SERVER_PROXY_PORT: v.positiveNum(),\r\n SERVER_PROXY_TIMEOUT: v.nonNegativeNum(),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: v.boolean(),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: v.nonNegativeNum(),\r\n SERVER_RATE_LIMITING_WINDOW: v.nonNegativeNum(),\r\n SERVER_RATE_LIMITING_DELAY: v.nonNegativeNum(),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: v.boolean(),\r\n SERVER_RATE_LIMITING_SKIP_KEY: v.string(),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: v.string(),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: v.boolean(),\r\n SERVER_SSL_FORCE: v.boolean(),\r\n SERVER_SSL_PORT: v.positiveNum(),\r\n SERVER_SSL_CERT_PATH: v.string(),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: v.nonNegativeNum(),\r\n POOL_MAX_WORKERS: v.nonNegativeNum(),\r\n POOL_WORK_LIMIT: v.positiveNum(),\r\n POOL_ACQUIRE_TIMEOUT: v.nonNegativeNum(),\r\n POOL_CREATE_TIMEOUT: v.nonNegativeNum(),\r\n POOL_DESTROY_TIMEOUT: v.nonNegativeNum(),\r\n POOL_IDLE_TIMEOUT: v.nonNegativeNum(),\r\n POOL_CREATE_RETRY_INTERVAL: v.nonNegativeNum(),\r\n POOL_REAPER_INTERVAL: v.nonNegativeNum(),\r\n POOL_BENCHMARKING: v.boolean(),\r\n\r\n // logger\r\n LOGGING_LEVEL: z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n value === '' ||\r\n (!isNaN(parseFloat(value)) &&\r\n parseFloat(value) >= 0 &&\r\n parseFloat(value) <= 5),\r\n (value) => ({\r\n message: `Invalid value for LOGGING_LEVEL. We only accept values from 0 to 5 as logging levels, received '${value}'`\r\n })\r\n )\r\n .transform((value) => (value !== '' ? parseFloat(value) : undefined)),\r\n LOGGING_FILE: v.string(),\r\n LOGGING_DEST: v.string(),\r\n LOGGING_TO_CONSOLE: v.boolean(),\r\n LOGGING_TO_FILE: v.boolean(),\r\n\r\n // ui\r\n UI_ENABLE: v.boolean(),\r\n UI_ROUTE: v.string(),\r\n\r\n // other\r\n OTHER_NODE_ENV: v.enum(['development', 'production', 'test']),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: v.boolean(),\r\n OTHER_NO_LOGO: v.boolean(),\r\n OTHER_HARD_RESET_PAGE: v.boolean(),\r\n OTHER_BROWSER_SHELL_MODE: v.boolean(),\r\n\r\n // debugger\r\n DEBUG_ENABLE: v.boolean(),\r\n DEBUG_HEADLESS: v.boolean(),\r\n DEBUG_DEVTOOLS: v.boolean(),\r\n DEBUG_LISTEN_TO_CONSOLE: v.boolean(),\r\n DEBUG_DUMPIO: v.boolean(),\r\n DEBUG_SLOW_MO: v.nonNegativeNum(),\r\n DEBUG_DEBUGGING_PORT: v.positiveNum()\r\n});\r\n\r\nexport const envs = Config.partial().parse(process.env);\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack } from './logger.js';\r\nimport { envs } from './envs.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n/**\r\n * Gets the reference to the global options of the server instance object\r\n * or its copy.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getReference=true] - Optional parameter to decide whether\r\n * to return the reference to the global options of the server instance object\r\n * or return a copy of it. The default value is true.\r\n *\r\n * @returns {Object} The reference to the global options of the server instance\r\n * object or its copy.\r\n */\r\nexport function getOptions(getReference = true) {\r\n return getReference ? globalOptions : deepCopy(globalOptions);\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server instance, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the first parameter (by default an empty object).\r\n * 5. Options from the CLI.\r\n *\r\n * @function setOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n * @param {boolean} [modifyGlobal=false] - Optional parameter to decide\r\n * whether to update and return the reference to the global options\r\n * of the server instance object or return a copy of it. The default value\r\n * is false.\r\n *\r\n * @returns {Object} The updated general options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setOptions(\r\n customOptions = {},\r\n cliArgs = [],\r\n modifyGlobal = false\r\n) {\r\n // Object for options loaded via the `loadConfig` option\r\n let configOptions = {};\r\n\r\n // Object for options from the CLI\r\n let cliOptions = {};\r\n\r\n // Only for the CLI usage\r\n if (cliArgs.length) {\r\n // Get options from the custom JSON loaded via the `loadConfig`\r\n configOptions = _loadConfigFile(cliArgs);\r\n\r\n // Get options from the CLI\r\n cliOptions = _pairArgumentValue(nestedProps, cliArgs);\r\n }\r\n\r\n // Get the reference to the global options object or a copy of the object\r\n const generalOptions = getOptions(modifyGlobal);\r\n\r\n // Update values of the general options with values from each source possible\r\n _updateOptions(\r\n defaultConfig,\r\n generalOptions,\r\n configOptions,\r\n customOptions,\r\n cliOptions\r\n );\r\n\r\n // Return options\r\n return generalOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n // Check if the `newOptions` is a correct object\r\n if (isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key];\r\n }\r\n }\r\n\r\n // Return the result options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (Object.prototype.toString.call(oldOptions) === '[object Object]') {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is false.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is false.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is false.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'))\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg')).toString().bold\r\n .yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n options[name] = Object.prototype.hasOwnProperty.call(item, 'value')\r\n ? item.value\r\n : _initGlobalOptions(item);\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Updates options object with values from various sources, following a specific\r\n * prioritization order. The function checks for values in the following order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The options object that will be updated with values\r\n * from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which may override configuration options.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateOptions(config, options, configOpt, customOpt, cliOpt) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the config entry of a specific option\r\n const entry = config[key];\r\n\r\n // Gather values for the options from every possible source, if exists\r\n const configVal = configOpt && configOpt[key];\r\n const customVal = customOpt && customOpt[key];\r\n const cliVal = cliOpt && cliOpt[key];\r\n\r\n // If the value not found, need to go deeper\r\n if (typeof entry.value === 'undefined') {\r\n _updateOptions(entry, options[key], configVal, customVal, cliVal);\r\n } else {\r\n // If a value from custom JSON options exists, it take precedence\r\n if (configVal !== undefined && configVal !== null) {\r\n options[key] = configVal;\r\n }\r\n\r\n // If a value from environment variables exists, it take precedence\r\n const envVal = envs[entry.envLink];\r\n if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n options[key] = envVal;\r\n }\r\n\r\n // If a value from user options exists, it take precedence\r\n if (customVal !== undefined && customVal !== null) {\r\n options[key] = customVal;\r\n }\r\n\r\n // If a value from CLI options exists, it take precedence\r\n if (cliVal !== undefined && cliVal !== null) {\r\n options[key] = cliVal;\r\n }\r\n }\r\n });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n // Check if the `loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `loadConfig` is present and has a correct value\r\n if (configFileName) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return JSON.parse(readFileSync(getAbsolutePath(configFileName)));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options.\r\n * It may include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n setOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath));\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } = highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (Object.keys(manifest.modules || {}).length !== numberOfModules) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Get the reference to the global options to update to the new version\r\n const options = getOptions();\r\n\r\n // Set to the new version\r\n options.highcharts.version = newVersion;\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is false.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n */\r\nexport async function createChart(options) {\r\n // Get required functions\r\n const { getOptions, merge, setOptions, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override userOptions with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in userOptions when forExport is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: options.export.height,\r\n width: options.export.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${options.export.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${options.export.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(\r\n `return ${options.export.globalOptions}`\r\n )();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = options.customLogic.callback\r\n ? new Function(`return ${options.customLogic.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (options.customLogic.customCode) {\r\n new Function('options', options.customLogic.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[options.export.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is false.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: join(__dirname, cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, options) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n let isSVG = false;\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await _setAsSvg(page, exportOptions.svg);\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await _setAsOptions(page, options);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, options.customLogic))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Sets the specified page's content with provided export input within\r\n * the window context using the `page.setContent` function.\r\n *\r\n * @async\r\n * @function _setAsSvg\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {Promise} A Promise that resolves after the content is set.\r\n */\r\nasync function _setAsSvg(page, svg) {\r\n await page.setContent(svgTemplate(svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n}\r\n\r\n/**\r\n * Sets the options with specified export input and sizes as configuration into\r\n * the `createChart` function within the window context using\r\n * the `page.evaluate` function.\r\n *\r\n * @async\r\n * @function _setAsOptions\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves after the configuration\r\n * is set.\r\n */\r\nasync function _setAsOptions(page, options) {\r\n await page.evaluate(createChart, options);\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { getOptions } from './config.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} [poolOptions=getOptions().pool] - Object containing `pool`\r\n * options. The default value is the global pool options of the export server\r\n * instance.\r\n * @param {Array.} [puppeteerArgs=[]] - Additional arguments\r\n * for Puppeteer launch. The default value is an empty array.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(\r\n poolOptions = getOptions().pool,\r\n puppeteerArgs = []\r\n) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Kills all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves after the workers are\r\n * killed, the pool is destroyed, and the browser is closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (getOptions().pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n options._requestId\r\n ? `[benchmark] Request [${options._requestId}] - `\r\n : '[benchmark] ',\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] ' +\r\n (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n `Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Perform an export on a puppeteer level\r\n const exportCounter = measureTime();\r\n const result = await puppeteerExport(workerHandle.page, options);\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n '[pool] ' +\r\n (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n 'Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.'\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n '[pool] ' +\r\n (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n `Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n options._requestId\r\n ? `[benchmark] Request [${options._requestId}] - `\r\n : '[benchmark] ',\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - Object containing `pool` options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { getOptions, mergeOptions, isAllowedConfig } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { killPool, postWork, getPoolStats } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the image in the provided outfile.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain at least one of the following\r\n * properties: `infile`, `instr`, `options`, or `svg` to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Perform an export\r\n await startExport(options, async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on the information\r\n * in the `batch` option. The `batch` is a string in the following format:\r\n * \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results are saved\r\n * in provided outfiles.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain the `batch` option to generate\r\n * valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n ...options,\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n }\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `customOptions` parameter is an object that\r\n * may be partial or complete set of options. The `endCallback` is called when\r\n * the export is completed, with the `error` object as the first argument\r\n * and the `data` object as the second, which contains the Base64 representation\r\n * of the chart in the `result` property and the full set of export options\r\n * in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing work or upon error occurance of the exporting process. The first\r\n * argument is `error` object and the `data` object is the second, that contains\r\n * the Base64 representation of the chart in the `result` property and the full\r\n * set of export options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(customOptions, endCallback) {\r\n try {\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Merge the custom options into default ones\r\n const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n // Get the export options\r\n const exportOptions = options.export;\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = fileContent;\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = fileContent;\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n *\r\n * @returns {Object} An object containing the calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is null.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n startExport,\r\n singleExport,\r\n batchExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} [rateLimitingOptions=getOptions().server.rateLimiting] -\r\n * Object containing `rateLimiting` options. The default value is the global\r\n * rate limiting options of the export server instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(\r\n app,\r\n rateLimitingOptions = getOptions().server.rateLimiting\r\n) {\r\n try {\r\n // Check if the rate limiting is enabled\r\n if (rateLimitingOptions.enable) {\r\n const msg =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n max: rateLimitingOptions.maxRequests || 30,\r\n window: rateLimitingOptions.window || 1,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || false,\r\n skipToken: rateLimitingOptions.skipToken || false\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per windowMs\r\n max: rateOptions.max,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message: msg });\r\n },\r\n default: () => {\r\n response.status(429).send(msg);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== false &&\r\n rateOptions.skipToken !== false &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.max} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport ExportError from './ExportError.js';\r\n\r\n/**\r\n * A custom HTTP error class that extends the `ExportError`. Used to handle\r\n * errors with HTTP status codes.\r\n */\r\nclass HttpError extends ExportError {\r\n /**\r\n * Creates an instance of the `HttpError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super(message, statusCode);\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {HttpError} The updated instance of the `HttpError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default HttpError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport {\r\n fixConstr,\r\n fixType,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new HttpError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the body is not correct.\r\n * @throws {HttpError} Throws an `HttpError` if the chart data from the body\r\n * is not correct.\r\n * @throws {HttpError} Throws an `HttpError` in case of the private range url\r\n * error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid().replace(/-/g, '');\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new HttpError(\r\n \"[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.\",\r\n 400\r\n );\r\n }\r\n\r\n // Get the allowCodeExecution option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new HttpError(\r\n \"[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.\",\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new HttpError(\r\n \"[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.\",\r\n 400\r\n );\r\n }\r\n\r\n // Get options from the body and store parsed structure in the request\r\n request.validatedOptions = {\r\n // Set the created ID as a `_requestId` property in the validated options\r\n _requestId: requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${fixType(body.type)}`,\r\n type: fixType(body.type, body.outfile),\r\n constr: fixConstr(body.constr),\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n };\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions._requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Got an incoming HTTP request with ID ${requestId}.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new HttpError(\r\n '[export] Unexpected return of the export result from the chart generation. Please check your request data.',\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(readFileSync(join(__dirname, 'package.json')));\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { envs } from '../../envs.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new HttpError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new HttpError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n const newVersion = request.params.newVersion;\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new HttpError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new HttpError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { getOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts HTTP or/and HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains all server related properties (see\r\n * the `server` section in the `lib/schemas/config.js` file for a reference).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} [serverOptions=getOptions().server] - Object containing\r\n * `server` options. The default value is the global server options\r\n * of the export server instance.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when the server should not be enabled or when no valid Express app\r\n * is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions = getOptions().server) {\r\n try {\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n healthRoutes(app);\r\n exportRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - Object containing `rateLimiting`\r\n * options.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n rateLimitingMiddleware(app, rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Cleans up function to trigger before ending process for the graceful\r\n * shutdown.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} exitCode - An exit code for the `process.exit()` function.\r\n */\r\nexport async function shutdownCleanUp(exitCode) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n setOptions,\r\n mergeOptions,\r\n mapToNewOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\nimport server, { startServer } from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage. This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n */\r\nexport async function initExport(customOptions) {\r\n // Get the global options object copy and extend it with the incoming options\r\n const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp(0);\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp(0);\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp(0);\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n server,\r\n startServer,\r\n\r\n // Options\r\n getOptions,\r\n setOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Cache\r\n checkAndUpdateCache,\r\n\r\n // Pool\r\n initPool,\r\n killPool,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n\r\n // Utils\r\n shutdownCleanUp\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","v","array","filterArray","z","string","transform","map","filter","boolean","enum","refine","positiveNum","isNaN","parseFloat","nonNegativeNum","Config","object","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","partial","parse","env","_initGlobalOptions","getOptions","getReference","setOptions","customOptions","cliArgs","modifyGlobal","configOptions","cliOptions","_loadConfigFile","_pairArgumentValue","generalOptions","_updateOptions","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","index","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","name","configOpt","customOpt","cliOpt","configVal","customVal","cliVal","envVal","stringifyFunctions","stringify","replaceAll","Error","configIndex","findIndex","arg","configFileName","i","option","async","fetch","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","ExportError","constructor","statusCode","super","this","setError","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","indexOf","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","proxyHost","proxyPort","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","additionalOptions","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","customLogicOptions","injectedResources","injectedJs","js","content","files","isLocal","jsResource","addScriptTag","injectedCss","css","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","exportOptions","isSVG","_setAsSvg","_setAsOptions","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","_requestId","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","uuid","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","data","batchExport","batchFunctions","pair","batchResults","allSettled","reason","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","msg","rateOptions","limiter","rateLimit","windowMs","delayMs","handler","format","send","default","skip","query","access_token","HttpError","setStatus","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","requestId","connection","remoteAddress","validatedOptions","params","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","adminToken","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","limit","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","enableRateLimiting","middlewares","shutdownCleanUp","exitCode","exit","initExport","_attachProcessExitListeners","code"],"mappings":"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B,GAGP,CCrOO,MAAMiB,cAAgB,CAC3BC,UAAW,CACT7B,KAAM,CACJvB,MAAO,CACL,mCACA,kBACA,0CACA,2BACA,kCACA,kCACA,wCACA,2CACA,qBACA,4BACA,2CACA,uDACA,6BACA,yBACA,0BACA,+BACA,uBACA,uFACA,yBACA,oCACA,oBACA,0BACA,8CACA,2BACA,0BACA,6BACA,mCACA,wCACA,mCACA,2BACA,kCACA,uBACA,iBACA,yBACA,8BACA,oBACA,2BACA,eACA,6BACA,iBACA,aACA,eACA,sBACA,cACA,yBACA,oBACA,uBAEFqD,MAAO,CAAC,YACRC,QAAS,iBACTC,QAAS,gBACTC,YAAa,+BACbC,cAAe,CACbnG,KAAM,OACNoG,UAAW,OAIjBC,WAAY,CACVC,QAAS,CACP5D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbnG,KAAM,SAGVuG,OAAQ,CACN7D,MAAO,8BACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbnG,KAAM,SAGVwG,WAAY,CACV9D,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbnG,KAAM,WAGVyG,UAAW,CACT/D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbnG,KAAM,SAGV0G,YAAa,CACXhE,MAAO,CAAC,aAAc,kBAAmB,iBACzCqD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbnG,KAAM,cACN2G,aAAc,0DAGlBC,cAAe,CACblE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbnG,KAAM,cACN2G,aAAc,0DAGlBE,iBAAkB,CAChBnE,MAAO,CAAC,kBACRqD,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbnG,KAAM,cACN2G,aAAc,0DAGlBG,cAAe,CACbpE,MAAO,CACL,wEACA,kGAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbnG,KAAM,OACNoG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACNtE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbnG,KAAM,SAGViH,MAAO,CACLvE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbnG,KAAM,SAGVkH,QAAS,CACPxE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbnG,KAAM,SAGVmH,IAAK,CACHzE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbnG,KAAM,SAGVoH,MAAO,CACL1E,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbnG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbnG,KAAM,SAGVA,KAAM,CACJ0C,MAAO,MACPqD,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,oDACbC,cAAe,CACbnG,KAAM,SACNqH,KAAM,eACNC,QAAS,CAAC,MAAO,OAAQ,MAAO,SAGpC5H,OAAQ,CACNgD,MAAO,QACPqD,MAAO,CAAC,UACRC,QAAS,gBACTE,YACE,uEACFC,cAAe,CACbnG,KAAM,SACNqH,KAAM,iBACNC,QAAS,CAAC,QAAS,aAAc,WAAY,gBAGjDC,IAAK,CACH7E,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,aACTE,YACE,oFACFC,cAAe,CACbnG,KAAM,WAGVwH,WAAY,CACV9E,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,qBACTE,YACE,0EACFC,cAAe,CACbnG,KAAM,WAGVyH,OAAQ,CACN/E,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YAAa,yDACbC,cAAe,CACbnG,KAAM,WAGV0H,MAAO,CACLhF,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YAAa,wDACbC,cAAe,CACbnG,KAAM,WAGV2H,MAAO,CACLjF,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gFACFC,cAAe,CACbnG,KAAM,WAGV4H,cAAe,CACblF,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,kDACbC,cAAe,CACbnG,KAAM,WAGV6H,aAAc,CACZnF,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,iDACbC,cAAe,CACbnG,KAAM,WAGV8H,aAAc,CACZpF,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YACE,yEACFC,cAAe,CACbnG,KAAM,SACN+H,IAAK,GACLC,IAAK,IAGTC,cAAe,CACbvF,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,wBACTE,YACE,mFACFC,cAAe,CACbnG,KAAM,SAGVkI,aAAc,CACZxF,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,uBACTE,YACE,kFACFC,cAAe,CACbnG,KAAM,SAGVmI,qBAAsB,CACpBzF,MAAO,KACPqD,MAAO,CAAC,UACRC,QAAS,+BACTE,YAAa,6CACbC,cAAe,CACbnG,KAAM,YAIZoI,YAAa,CACXC,mBAAoB,CAClB3F,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oCACTE,YACE,mEACFC,cAAe,CACbnG,KAAM,WAGVkD,mBAAoB,CAClBR,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oCACTE,YACE,kFACFC,cAAe,CACbnG,KAAM,WAGViD,WAAY,CACVP,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,2BACTE,YACE,uHACFC,cAAe,CACbnG,KAAM,SAGVsI,SAAU,CACR5F,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,wBACTE,YACE,kFACFC,cAAe,CACbnG,KAAM,SAGVuI,UAAW,CACT7F,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,yBACTE,YACE,sGACFC,cAAe,CACbnG,KAAM,SAGVwI,WAAY,CACV9F,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,2BACTyC,WAAY,WACZvC,YAAa,+CACbC,cAAe,CACbnG,KAAM,SAGV0I,aAAc,CACZhG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,6BACTE,YACE,+DACFC,cAAe,CACbnG,KAAM,UAIZ2I,OAAQ,CACNC,OAAQ,CACNlG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,gBACTC,QAAS,eACTC,YAAa,8BACbC,cAAe,CACbnG,KAAM,WAGV6I,KAAM,CACJnG,MAAO,UACPqD,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,yBACbC,cAAe,CACbnG,KAAM,SAGV8I,KAAM,CACJpG,MAAO,KACPqD,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,6BACbC,cAAe,CACbnG,KAAM,WAGV+I,YAAa,CACXrG,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,sBACTE,YAAa,kCACbC,cAAe,CACbnG,KAAM,WAGVgJ,aAAc,CACZtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,sBACTC,QAAS,qBACTC,YACE,0EACFC,cAAe,CACbnG,KAAM,WAGViJ,MAAO,CACLJ,KAAM,CACJnG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,oBACTC,QAAS,YACTC,YAAa,0CACbC,cAAe,CACbnG,KAAM,SAGV8I,KAAM,CACJpG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,oBACTC,QAAS,YACTC,YAAa,0CACbC,cAAe,CACbnG,KAAM,WAGVkJ,QAAS,CACPxG,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTC,QAAS,eACTC,YACE,8DACFC,cAAe,CACbnG,KAAM,YAIZmJ,aAAc,CACZP,OAAQ,CACNlG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,8BACTC,QAAS,qBACTC,YAAa,kDACbC,cAAe,CACbnG,KAAM,WAGVoJ,YAAa,CACX1G,MAAO,GACPqD,MAAO,CAAC,UACRC,QAAS,oCACTyC,WAAY,YACZvC,YAAa,gDACbC,cAAe,CACbnG,KAAM,WAGVqJ,OAAQ,CACN3G,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,8BACTE,YAAa,2CACbC,cAAe,CACbnG,KAAM,WAGVsJ,MAAO,CACL5G,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,6BACTE,YACE,uEACFC,cAAe,CACbnG,KAAM,WAGVuJ,WAAY,CACV7G,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,mCACTE,YAAa,sDACbC,cAAe,CACbnG,KAAM,WAGVwJ,QAAS,CACP9G,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gCACTE,YAAa,wDACbC,cAAe,CACbnG,KAAM,SAGVyJ,UAAW,CACT/G,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,kCACTE,YAAa,wDACbC,cAAe,CACbnG,KAAM,UAIZ0J,IAAK,CACHd,OAAQ,CACNlG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oBACTC,QAAS,YACTC,YAAa,mCACbC,cAAe,CACbnG,KAAM,WAGV2J,MAAO,CACLjH,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,mBACTC,QAAS,WACTwC,WAAY,UACZvC,YAAa,gDACbC,cAAe,CACbnG,KAAM,WAGV8I,KAAM,CACJpG,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,kBACTC,QAAS,UACTC,YAAa,0BACbC,cAAe,CACbnG,KAAM,WAGV4J,SAAU,CACRlH,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,uBACTC,QAAS,cACTwC,WAAY,UACZvC,YAAa,uCACbC,cAAe,CACbnG,KAAM,WAKd6J,KAAM,CACJC,WAAY,CACVpH,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,mBACTE,YAAa,sDACbC,cAAe,CACbnG,KAAM,WAGV+J,WAAY,CACVrH,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,mBACTyC,WAAY,UACZvC,YAAa,0CACbC,cAAe,CACbnG,KAAM,WAGVgK,UAAW,CACTtH,MAAO,GACPqD,MAAO,CAAC,UACRC,QAAS,kBACTE,YAAa,wDACbC,cAAe,CACbnG,KAAM,WAGViK,eAAgB,CACdvH,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,mDACbC,cAAe,CACbnG,KAAM,WAGVkK,cAAe,CACbxH,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,sBACTE,YAAa,kDACbC,cAAe,CACbnG,KAAM,WAGVmK,eAAgB,CACdzH,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,oDACbC,cAAe,CACbnG,KAAM,WAGVoK,YAAa,CACX1H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,oBACTE,YAAa,wDACbC,cAAe,CACbnG,KAAM,WAGVqK,oBAAqB,CACnB3H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,6BACTE,YACE,wEACFC,cAAe,CACbnG,KAAM,WAGVsK,eAAgB,CACd5H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YACE,+DACFC,cAAe,CACbnG,KAAM,WAGVgJ,aAAc,CACZtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oBACTC,QAAS,mBACTC,YAAa,6CACbC,cAAe,CACbnG,KAAM,YAIZwD,QAAS,CACPY,MAAO,CACL1B,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,gBACTC,QAAS,WACTC,YAAa,0BACbC,cAAe,CACbnG,KAAM,SACN+C,MAAO,EACPgF,IAAK,EACLC,IAAK,IAGT1C,KAAM,CACJ5C,MAAO,+BACPqD,MAAO,CAAC,UACRC,QAAS,eACTC,QAAS,UACTC,YACE,8DACFC,cAAe,CACbnG,KAAM,SAGVqF,KAAM,CACJ3C,MAAO,MACPqD,MAAO,CAAC,UACRC,QAAS,eACTC,QAAS,UACTC,YAAa,0DACbC,cAAe,CACbnG,KAAM,SAGVyD,UAAW,CACTf,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,qBACTC,QAAS,eACTC,YAAa,sCACbC,cAAe,CACbnG,KAAM,WAGV0D,OAAQ,CACNhB,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,kBACTC,QAAS,YACTC,YAAa,wCACbC,cAAe,CACbnG,KAAM,YAIZuK,GAAI,CACF3B,OAAQ,CACNlG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,YACTC,QAAS,WACTC,YAAa,mDACbC,cAAe,CACbnG,KAAM,WAGVwK,MAAO,CACL9H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,WACTC,QAAS,UACTC,YAAa,gCACbC,cAAe,CACbnG,KAAM,UAIZyK,MAAO,CACLC,QAAS,CACPhI,MAAO,aACPqD,MAAO,CAAC,UACRC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbnG,KAAM,SAGV2K,qBAAsB,CACpBjI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,gCACTE,YAAa,iDACbC,cAAe,CACbnG,KAAM,WAGV4K,OAAQ,CACNlI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,gBACTE,YAAa,+CACbC,cAAe,CACbnG,KAAM,WAGV6K,cAAe,CACbnI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,wBACTE,YAAa,oDACbC,cAAe,CACbnG,KAAM,WAGV8K,iBAAkB,CAChBpI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,2BACTE,YAAa,yDACbC,cAAe,CACbnG,KAAM,YAIZ+K,MAAO,CACLnC,OAAQ,CACNlG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,eACTC,QAAS,cACTC,YAAa,4DACbC,cAAe,CACbnG,KAAM,WAGVgL,SAAU,CACRtI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,iBACTE,YACE,6EACFC,cAAe,CACbnG,KAAM,WAGViL,SAAU,CACRvI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,iBACTE,YAAa,+CACbC,cAAe,CACbnG,KAAM,WAGVkL,gBAAiB,CACfxI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,0BACTE,YACE,qEACFC,cAAe,CACbnG,KAAM,WAGVmL,OAAQ,CACNzI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,eACTE,YACE,kFACFC,cAAe,CACbnG,KAAM,WAGVoL,OAAQ,CACN1I,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,gBACTE,YAAa,4DACbC,cAAe,CACbnG,KAAM,WAGVqL,cAAe,CACb3I,MAAO,KACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,0BACbC,cAAe,CACbnG,KAAM,aAODsL,YAAcC,mBAAmB1F,eAGjC2F,cAAgBC,qBAAqB5F,eAoBlD,SAAS0F,mBAAmBG,EAAQJ,EAAc,CAAA,EAAIK,EAAY,IAqBhE,OApBAtM,OAAOwC,KAAK6J,GAAQE,SAASxM,IAE3B,MAAMyM,EAAQH,EAAOtM,QAGM,IAAhByM,EAAMnJ,MAEf6I,mBAAmBM,EAAOP,EAAa,GAAGK,KAAavM,MAGvDkM,EAAYO,EAAM5F,SAAW7G,GAAO,GAAGuM,KAAavM,IAAM0M,UAAU,QAG3CrH,IAArBoH,EAAMpD,aACR6C,EAAYO,EAAMpD,YAAc,GAAGkD,KAAavM,IAAM0M,UAAU,IAEnE,IAIIR,CACT,CAiBA,SAASG,qBAAqBC,EAAQF,EAAgB,IAkBpD,OAjBAnM,OAAOwC,KAAK6J,GAAQE,SAASxM,IAE3B,MAAMyM,EAAQH,EAAOtM,QAGM,IAAhByM,EAAM9F,MAEf0F,qBAAqBI,EAAOL,GAGxBK,EAAM9F,MAAMjG,SAAS,WACvB0L,EAActG,KAAK9F,EAEtB,IAIIoM,CACT,CCrhCAO,OAAOL,SAIP,MAAMM,EAAI,CAGRC,MAAQC,GACNC,EACGC,SACAC,WAAW3J,GACVA,EACGvC,MAAM,KACNmM,KAAK5J,GAAUA,EAAMnB,SACrBgL,QAAQ7J,GAAUwJ,EAAYpM,SAAS4C,OAE3C2J,WAAW3J,GAAWA,EAAMZ,OAASY,OAAQ+B,IAIlD+H,QAAS,IACPL,EACGM,KAAK,CAAC,OAAQ,QAAS,KACvBJ,WAAW3J,GAAqB,KAAVA,EAAyB,SAAVA,OAAmB+B,IAI7DgI,KAAOjM,GACL2L,EACGM,KAAK,IAAIjM,EAAQ,KACjB6L,WAAW3J,GAAqB,KAAVA,EAAeA,OAAQ+B,IAIlD2H,OAAQ,IACND,EACGC,SACA7K,OACAmL,QACEhK,IACE,CAAC,QAAS,YAAa,OAAQ,OAAO5C,SAAS4C,IACtC,KAAVA,IACDA,IAAW,CACVqC,QAAS,mDAAmDrC,SAG/D2J,WAAW3J,GAAqB,KAAVA,EAAeA,OAAQ+B,IAIlDkI,YAAa,IACXR,EACGC,SACA7K,OACAmL,QACEhK,GACW,KAAVA,IAAkBkK,MAAMC,WAAWnK,KAAWmK,WAAWnK,GAAS,IACnEA,IAAW,CACVqC,QAAS,qDAAqDrC,SAGjE2J,WAAW3J,GAAqB,KAAVA,EAAemK,WAAWnK,QAAS+B,IAI9DqI,eAAgB,IACdX,EACGC,SACA7K,OACAmL,QACEhK,GACW,KAAVA,IAAkBkK,MAAMC,WAAWnK,KAAWmK,WAAWnK,IAAU,IACpEA,IAAW,CACVqC,QAAS,yDAAyDrC,SAGrE2J,WAAW3J,GAAqB,KAAVA,EAAemK,WAAWnK,QAAS+B,KAGnDsI,OAASZ,EAAEa,OAAO,CAE7BC,eAAgBjB,EAAEI,SAGlBc,mBAAoBf,EACjBC,SACA7K,OACAmL,QACEhK,GAAU,6BAA6BR,KAAKQ,IAAoB,KAAVA,IACtDA,IAAW,CACVqC,QAAS,4FAA4FrC,SAGxG2J,WAAW3J,GAAqB,KAAVA,EAAeA,OAAQ+B,IAChD0I,mBAAoBhB,EACjBC,SACA7K,OACAmL,QACEhK,GACCA,EAAMY,WAAW,aACjBZ,EAAMY,WAAW,YACP,KAAVZ,IACDA,IAAW,CACVqC,QAAS,6FAA6FrC,SAGzG2J,WAAW3J,GAAqB,KAAVA,EAAeA,OAAQ+B,IAChD2I,uBAAwBpB,EAAEQ,UAC1Ba,sBAAuBrB,EAAEI,SACzBkB,uBAAwBtB,EAAEI,SAC1BmB,wBAAyBvB,EAAEC,MAAMpG,cAAcQ,WAAWK,YAAYhE,OACtE8K,0BAA2BxB,EAAEC,MAC3BpG,cAAcQ,WAAWO,cAAclE,OAEzC+K,6BAA8BzB,EAAEC,MAC9BpG,cAAcQ,WAAWQ,iBAAiBnE,OAE5CgL,0BAA2B1B,EAAEC,MAC3BpG,cAAcQ,WAAWS,cAAcpE,OAIzCiL,cAAe3B,EAAEI,SACjBwB,aAAc5B,EAAEI,SAChByB,eAAgB7B,EAAEI,SAClB0B,WAAY9B,EAAEI,SACd2B,aAAc/B,EAAEI,SAChB4B,eAAgBhC,EAAEI,SAClB6B,YAAajC,EAAES,KAAK,CAAC,OAAQ,MAAO,MAAO,QAC3CyB,cAAelC,EAAES,KAAK,CAAC,QAAS,aAAc,WAAY,eAC1D0B,WAAYnC,EAAEQ,UACd4B,mBAAoBpC,EAAEQ,UACtB6B,cAAerC,EAAEW,cACjB2B,aAActC,EAAEW,cAChB4B,aAAcvC,EAAEW,cAChB6B,sBAAuBxC,EAAEW,cACzB8B,qBAAsBzC,EAAEW,cACxB+B,qBAAsB1C,EAAEW,cACxBgC,sBAAuB3C,EAAEI,SACzBwC,qBAAsB5C,EAAEI,SACxByC,6BAA8B7C,EAAEc,iBAGhCgC,kCAAmC9C,EAAEQ,UACrCuC,kCAAmC/C,EAAEQ,UACrCwC,yBAA0BhD,EAAEI,SAC5B6C,sBAAuBjD,EAAEI,SACzB8C,uBAAwBlD,EAAEI,SAC1B+C,yBAA0BnD,EAAEI,SAC5BgD,2BAA4BpD,EAAEI,SAG9BiD,cAAerD,EAAEQ,UACjB8C,YAAatD,EAAEI,SACfmD,YAAavD,EAAEW,cACf6C,oBAAqBxD,EAAEW,cACvB8C,oBAAqBzD,EAAEQ,UAGvBkD,kBAAmB1D,EAAEI,SACrBuD,kBAAmB3D,EAAEW,cACrBiD,qBAAsB5D,EAAEc,iBAGxB+C,4BAA6B7D,EAAEQ,UAC/BsD,kCAAmC9D,EAAEc,iBACrCiD,4BAA6B/D,EAAEc,iBAC/BkD,2BAA4BhE,EAAEc,iBAC9BmD,iCAAkCjE,EAAEQ,UACpC0D,8BAA+BlE,EAAEI,SACjC+D,gCAAiCnE,EAAEI,SAGnCgE,kBAAmBpE,EAAEQ,UACrB6D,iBAAkBrE,EAAEQ,UACpB8D,gBAAiBtE,EAAEW,cACnB4D,qBAAsBvE,EAAEI,SAGxBoE,iBAAkBxE,EAAEc,iBACpB2D,iBAAkBzE,EAAEc,iBACpB4D,gBAAiB1E,EAAEW,cACnBgE,qBAAsB3E,EAAEc,iBACxB8D,oBAAqB5E,EAAEc,iBACvB+D,qBAAsB7E,EAAEc,iBACxBgE,kBAAmB9E,EAAEc,iBACrBiE,2BAA4B/E,EAAEc,iBAC9BkE,qBAAsBhF,EAAEc,iBACxBmE,kBAAmBjF,EAAEQ,UAGrB0E,cAAe/E,EACZC,SACA7K,OACAmL,QACEhK,GACW,KAAVA,IACEkK,MAAMC,WAAWnK,KACjBmK,WAAWnK,IAAU,GACrBmK,WAAWnK,IAAU,IACxBA,IAAW,CACVqC,QAAS,mGAAmGrC,SAG/G2J,WAAW3J,GAAqB,KAAVA,EAAemK,WAAWnK,QAAS+B,IAC5D0M,aAAcnF,EAAEI,SAChBgF,aAAcpF,EAAEI,SAChBiF,mBAAoBrF,EAAEQ,UACtB8E,gBAAiBtF,EAAEQ,UAGnB+E,UAAWvF,EAAEQ,UACbgF,SAAUxF,EAAEI,SAGZqF,eAAgBzF,EAAES,KAAK,CAAC,cAAe,aAAc,SACrDiF,8BAA+B1F,EAAEQ,UACjCmF,cAAe3F,EAAEQ,UACjBoF,sBAAuB5F,EAAEQ,UACzBqF,yBAA0B7F,EAAEQ,UAG5BsF,aAAc9F,EAAEQ,UAChBuF,eAAgB/F,EAAEQ,UAClBwF,eAAgBhG,EAAEQ,UAClByF,wBAAyBjG,EAAEQ,UAC3B0F,aAAclG,EAAEQ,UAChB2F,cAAenG,EAAEc,iBACjBsF,qBAAsBpG,EAAEW,gBAGb0F,KAAOtF,OAAOuF,UAAUC,MAAMlQ,QAAQmQ,KCvO7CvK,cAAgBwK,mBAAmB5M,eAelC,SAAS6M,WAAWC,GAAe,GACxC,OAAOA,EAAe1K,cAAgBlJ,SAASkJ,cACjD,CA8BO,SAAS2K,WACdC,EAAgB,CAAE,EAClBC,EAAU,GACVC,GAAe,GAGf,IAAIC,EAAgB,CAAA,EAGhBC,EAAa,CAAA,EAGbH,EAAQhR,SAEVkR,EAAgBE,gBAAgBJ,GAGhCG,EAAaE,mBAAmB7H,YAAawH,IAI/C,MAAMM,EAAiBV,WAAWK,GAYlC,OATAM,eACExN,cACAuN,EACAJ,EACAH,EACAI,GAIKG,CACT,CAYO,SAASE,aAAaC,EAAiBC,GAE5C,GAAI9R,SAAS8R,GACX,IAAK,MAAOpU,EAAKsD,KAAUrD,OAAOoU,QAAQD,GACxCD,EAAgBnU,GACdsC,SAASgB,KACR8I,cAAc1L,SAASV,SACCqF,IAAzB8O,EAAgBnU,GACZkU,aAAaC,EAAgBnU,GAAMsD,QACzB+B,IAAV/B,EACEA,EACA6Q,EAAgBnU,GAK5B,OAAOmU,CACT,CAkBO,SAASG,gBAAgBC,GAE9B,MAAMH,EAAa,CAAA,EAGnB,GAAmD,oBAA/CnU,OAAOC,UAAU8B,SAAS5B,KAAKmU,GAEjC,IAAK,MAAOvU,EAAKsD,KAAUrD,OAAOoU,QAAQE,GAAa,CAErD,MAAMC,EAAkBtI,YAAYlM,GAChCkM,YAAYlM,GAAKe,MAAM,KACvB,GAIJyT,EAAgBC,QACd,CAACC,EAAKC,EAAMC,IACTF,EAAIC,GACHH,EAAgB9R,OAAS,IAAMkS,EAAQtR,EAAQoR,EAAIC,IAAS,IAChEP,EAEH,CAIH,OAAOA,CACT,CAoBO,SAASS,gBACdvI,OACAtK,UAAW,EACX8S,gBAAiB,GAEjB,IAEE,IAAKxS,SAASgK,SAA6B,iBAAXA,OAE9B,OAAO,KAIT,MAAMyI,aACc,iBAAXzI,OACHwI,eACEE,KAAK,IAAI1I,WACT2I,KAAK9B,MAAM7G,QACbA,OAGA4I,mBAAqBC,kBACzBJ,aACAD,gBACA,GAIIM,cAAgBN,eAClBG,KAAK9B,MACHgC,kBAAkBJ,aAAcD,gBAAgB,IAChD,CAACO,EAAG/R,QACe,iBAAVA,OAAsBA,MAAMY,WAAW,YAC1C8Q,KAAK,IAAI1R,UACTA,QAER2R,KAAK9B,MAAM+B,oBAGf,OAAOlT,SAAWkT,mBAAqBE,aACxC,CAAC,MAAO5P,GAEP,OAAO,IACR,CACH,CAsFA,SAAS6N,mBAAmB/G,GAC1B,MAAMxE,EAAU,CAAA,EAGhB,IAAK,MAAOwN,EAAM/S,KAAStC,OAAOoU,QAAQ/H,GACxCxE,EAAQwN,GAAQrV,OAAOC,UAAUC,eAAeC,KAAKmC,EAAM,SACvDA,EAAKe,MACL+P,mBAAmB9Q,GAIzB,OAAOuF,CACT,CAuBA,SAASmM,eAAe3H,EAAQxE,EAASyN,EAAWC,EAAWC,GAC7DxV,OAAOwC,KAAK6J,GAAQE,SAASxM,IAE3B,MAAMyM,EAAQH,EAAOtM,GAGf0V,EAAYH,GAAaA,EAAUvV,GACnC2V,EAAYH,GAAaA,EAAUxV,GACnC4V,EAASH,GAAUA,EAAOzV,GAGhC,QAA2B,IAAhByM,EAAMnJ,MACf2Q,eAAexH,EAAO3E,EAAQ9H,GAAM0V,EAAWC,EAAWC,OACrD,CAEDF,UACF5N,EAAQ9H,GAAO0V,GAIjB,MAAMG,EAAS5C,KAAKxG,EAAM7F,SACtB6F,EAAM7F,WAAWqM,MAAjBxG,MAAyBoJ,IAC3B/N,EAAQ9H,GAAO6V,GAIbF,UACF7N,EAAQ9H,GAAO2V,GAIbC,UACF9N,EAAQ9H,GAAO4V,EAElB,IAEL,CAsBO,SAAST,kBAAkBrN,EAASgN,EAAgBgB,GAiCzD,OAAOb,KAAKc,UAAUjO,GAhCG,CAACuN,EAAG/R,KAO3B,GALqB,iBAAVA,IACTA,EAAQA,EAAMnB,QAKG,mBAAVmB,GACW,iBAAVA,GACNA,EAAMY,WAAW,aACjBZ,EAAMU,SAAS,KACjB,CAEA,GAAI8Q,EAEF,OAAOgB,EAEH,YAAYxS,EAAQ,IAAI0S,WAAW,OAAQ,eAE3C,WAAW1S,EAAQ,IAAI0S,WAAW,OAAQ,cAG9C,MAAM,IAAIC,KAEb,CAGD,OAAO3S,CAAK,IAImC0S,WAC/CF,EAAqB,yBAA2B,qBAChD,GAEJ,CAeA,SAAShC,gBAAgBJ,GAEvB,MAAMwC,EAAcxC,EAAQyC,WACzBC,GAAkC,eAA1BA,EAAI3V,QAAQ,KAAM,MAIvB4V,EAAiBH,GAAe,GAAKxC,EAAQwC,EAAc,GAGjE,GAAIG,EACF,IAEE,OAAOpB,KAAK9B,MAAMlP,aAAanD,gBAAgBuV,IAChD,CAAC,MAAO7Q,GACPD,aACE,EACAC,EACA,sDAAsD6Q,UAEzD,CAIH,MAAO,EACT,CAkBA,SAAStC,mBAAmB7H,EAAawH,GAEvC,MAAMG,EAAa,CAAA,EAGnB,IAAK,IAAIyC,EAAI,EAAGA,EAAI5C,EAAQhR,OAAQ4T,IAAK,CACvC,MAAMC,EAAS7C,EAAQ4C,GAAG7V,QAAQ,KAAM,IAGlC+T,EAAkBtI,EAAYqK,GAChCrK,EAAYqK,GAAQxV,MAAM,KAC1B,GAGJyT,EAAgBC,QAAO,CAACC,EAAKC,EAAMC,KACjC,GAAIJ,EAAgB9R,OAAS,IAAMkS,EAAO,CACxC,MAAMtR,EAAQoQ,IAAU4C,GACnBhT,GACHsB,IACE,EACA,yCAAyC2R,yCAG7C7B,EAAIC,GAAQrR,GAAS,IACtB,WAAwB+B,IAAdqP,EAAIC,KACbD,EAAIC,GAAQ,IAEd,OAAOD,EAAIC,EAAK,GACfd,EACJ,CAGD,OAAOA,CACT,CCvgBO2C,eAAeC,MAAM/W,EAAKgX,EAAiB,IAChD,OAAO,IAAIC,SAAQ,CAACC,EAASC,KAC3BC,mBAAmBpX,GAChBqX,IAAIrX,EAAKgX,GAAiBM,IACzB,IAAIC,EAAe,GAGnBD,EAASE,GAAG,QAASC,IACnBF,GAAgBE,CAAK,IAIvBH,EAASE,GAAG,OAAO,KACZD,GACHJ,EAAO,qCAETG,EAASI,KAAOH,EAChBL,EAAQI,EAAS,GACjB,IAEHE,GAAG,SAAU1R,IACZqR,EAAOrR,EAAM,GACb,GAER,CAwEA,SAASsR,mBAAmBpX,GAC1B,OAAOA,EAAIwE,WAAW,SAAWmT,MAAQC,IAC3C,CCpHA,MAAMC,oBAAoBtB,MAQxB,WAAAuB,CAAY7R,EAAS8R,GACnBC,QAEAC,KAAKhS,QAAUA,EACfgS,KAAK/R,aAAeD,EAEhB8R,IACFE,KAAKF,WAAaA,EAErB,CAUD,QAAAG,CAASpS,GAgBP,OAfAmS,KAAKnS,MAAQA,EAETA,EAAM8P,OACRqC,KAAKrC,KAAO9P,EAAM8P,MAGhB9P,EAAMiS,aACRE,KAAKF,WAAajS,EAAMiS,YAGtBjS,EAAMK,QACR8R,KAAK/R,aAAeJ,EAAMG,QAC1BgS,KAAK9R,MAAQL,EAAMK,OAGd8R,IACR,EC3BH,MAAME,MAAQ,CACZ1Q,OAAQ,8BACR2Q,eAAgB,CAAE,EAClBC,QAAS,GACTC,UAAW,IAcNxB,eAAeyB,oBACpBC,EACAC,GAEA,IAAIC,EAGJ,MAAM/Q,EAAYgR,eAGZC,EAAe3W,KAAK0F,EAAW,iBAC/BkR,EAAa5W,KAAK0F,EAAW,cAOnC,IAJCf,WAAWe,IAAcd,UAAUc,EAAW,CAAEmR,WAAW,KAIvDlS,WAAWgS,IAAiBJ,EAAkB9Q,WACjDxC,IAAI,EAAG,yDACPwT,QAAuBK,aACrBP,EACAC,EACAI,OAEG,CACL,IAAIG,GAAgB,EAGpB,MAAMC,EAAW1D,KAAK9B,MAAMlP,aAAaqU,IAIzC,GAAIK,EAASC,SAAW9Y,MAAMC,QAAQ4Y,EAASC,SAAU,CACvD,MAAMC,EAAY,CAAA,EAClBF,EAASC,QAAQpM,SAASsM,GAAOD,EAAUC,GAAK,IAChDH,EAASC,QAAUC,CACpB,CAGD,MAAMvR,YAAEA,EAAWE,cAAEA,EAAaC,iBAAEA,GAAqByQ,EACnDa,EACJzR,EAAY5E,OAAS8E,EAAc9E,OAAS+E,EAAiB/E,OAK3DiW,EAASzR,UAAYgR,EAAkBhR,SACzCtC,IACE,EACA,yEAEF8T,GAAgB,GACPzY,OAAOwC,KAAKkW,EAASC,SAAW,IAAIlW,SAAWqW,GACxDnU,IACE,EACA,+EAEF8T,GAAgB,GAGhBA,GAAiBlR,GAAiB,IAAI5E,MAAMoW,IAC1C,IAAKL,EAASC,QAAQI,GAKpB,OAJApU,IACE,EACA,eAAeoU,iDAEV,CACR,IAKDN,EACFN,QAAuBK,aACrBP,EACAC,EACAI,IAGF3T,IAAI,EAAG,uDAGPiT,MAAME,QAAU9T,aAAasU,EAAY,QAGzCH,EAAiBO,EAASC,QAG1Bf,MAAMG,UAAYiB,eAAepB,MAAME,SAE1C,OAIKmB,sBAAsBhB,EAAmBE,EACjD,CASO,SAASe,uBACd,OAAOtB,MAAMG,SACf,CAWOxB,eAAe4C,wBAAwBC,GAE5C,MAAMvR,EAAUwL,aAGhBxL,EAAQb,WAAWC,QAAUmS,QAGvBpB,oBAAoBnQ,EAAQb,WAAYa,EAAQyB,OAAOM,MAC/D,CAWO,SAASoP,eAAeK,GAC7B,OAAOA,EACJ5M,UAAU,EAAG4M,EAAaC,QAAQ,OAClC9Y,QAAQ,KAAM,IACdA,QAAQ,KAAM,IACdA,QAAQ,MAAO,IACf0B,MACL,CAYO,SAASqX,kBAAkBC,GAChC,OAAOA,EAAWhZ,QAChB,qEACA,GAEJ,CAoBO,SAAS4X,eACd,OAAOvX,gBAAgBwS,aAAarM,WAAWI,UACjD,CAuBAmP,eAAekD,uBACbC,EACAjD,EACA0B,EACAwB,GAAmB,GAGfD,EAAO3V,SAAS,SAClB2V,EAASA,EAAOjN,UAAU,EAAGiN,EAAOjX,OAAS,IAE/CkC,IAAI,EAAG,6BAA6B+U,QAGpC,MAAM3C,QAAiBP,MAAM,GAAGkD,OAAajD,GAG7C,GAA4B,MAAxBM,EAASS,YAA8C,iBAAjBT,EAASI,KAAkB,CACnE,GAAIgB,EAAgB,CAElBA,EADmBoB,kBAAkBG,IACR,CAC9B,CACD,OAAO3C,EAASI,IACjB,CAGD,GAAIwC,EACF,MAAM,IAAIrC,YACR,+BAA+BoC,2EAAgF3C,EAASS,eACxH,KACAG,SAASZ,GAEXpS,IACE,EACA,+BAA+B+U,6DAGrC,CAgBAnD,eAAe0C,sBAAsBhB,EAAmBE,EAAiB,IACvE,MAAMyB,EAAc,CAClB3S,QAASgR,EAAkBhR,QAC3B0R,QAASR,GAIXP,MAAMC,eAAiB+B,EAEvBjV,IAAI,EAAG,mCACP,IACEkV,cACEnY,KAAK0W,eAAgB,iBACrBpD,KAAKc,UAAU8D,GACf,OAEH,CAAC,MAAOrU,GACP,MAAM,IAAI+R,YACR,4CACA,KACAK,SAASpS,EACZ,CACH,CAuBAgR,eAAeuD,cACbzS,EACAE,EACAE,EACAyQ,EACAC,GAGA,IAAI4B,EACJ,MAAMC,EAAY9B,EAAmB1O,KAC/ByQ,EAAY/B,EAAmBzO,KAGrC,GAAIuQ,GAAaC,EACf,IACEF,EAAa,IAAIG,gBAAgB,CAC/B1Q,KAAMwQ,EACNvQ,KAAMwQ,GAET,CAAC,MAAO1U,GACP,MAAM,IAAI+R,YACR,0CACA,KACAK,SAASpS,EACZ,CAIH,MAAMkR,EAAiBsD,EACnB,CACEI,MAAOJ,EACPlQ,QAASqO,EAAmBrO,SAE9B,GAEEuQ,EAAmB,IACpB/S,EAAY4F,KAAKyM,GAClBD,uBAAuB,GAAGC,IAAUjD,EAAgB0B,GAAgB,QAEnE5Q,EAAc0F,KAAKyM,GACpBD,uBAAuB,GAAGC,IAAUjD,EAAgB0B,QAEnD1Q,EAAcwF,KAAKyM,GACpBD,uBAAuB,GAAGC,IAAUjD,MAKxC,aAD6BC,QAAQ2D,IAAID,IACnB1Y,KAAK,MAC7B,CAmBA6U,eAAeiC,aAAaP,EAAmBC,EAAoBI,GAEjE,MAAMP,EAC0B,WAA9BE,EAAkBhR,QACd,KACA,GAAGgR,EAAkBhR,UAGrBC,EAAS+Q,EAAkB/Q,QAAU0Q,MAAM1Q,OAEjD,IACE,MAAMiR,EAAiB,CAAA,EAuCvB,OArCAxT,IACE,EACA,iDAAiDoT,GAAa,aAGhEH,MAAME,cAAgBgC,cACpB,IACK7B,EAAkB5Q,YAAY4F,KAAKqN,GACpCvC,EAAY,GAAG7Q,KAAU6Q,KAAauC,IAAM,GAAGpT,KAAUoT,OAG7D,IACKrC,EAAkB1Q,cAAc0F,KAAK4L,GAChC,QAANA,EACId,EACE,GAAG7Q,UAAe6Q,aAAqBc,IACvC,GAAG3R,kBAAuB2R,IAC5Bd,EACE,GAAG7Q,KAAU6Q,aAAqBc,IAClC,GAAG3R,aAAkB2R,SAE1BZ,EAAkBzQ,iBAAiByF,KAAKoJ,GACzC0B,EACI,GAAG7Q,WAAgB6Q,gBAAwB1B,IAC3C,GAAGnP,sBAA2BmP,OAGtC4B,EAAkBxQ,cAClByQ,EACAC,GAIFP,MAAMG,UAAYiB,eAAepB,MAAME,SAGvC+B,cAAcvB,EAAYV,MAAME,SACzBK,CACR,CAAC,MAAO5S,GACP,MAAM,IAAI+R,YACR,uDACA,KACAK,SAASpS,EACZ,CACH,CCtcO,SAASgV,kBACdC,WAAWC,WAAa,WACtB,MAAO,CAAEC,SAAU,EACvB,CACA,CAWOnE,eAAeoE,YAAY9S,GAEhC,MAAMwL,WAAEA,EAAUuH,MAAEA,EAAKrH,WAAEA,EAAUsH,KAAEA,GAASL,WAIhDA,WAAWM,cAAgBF,GAAM,EAAO,CAAE,EAAEvH,KAG5CrJ,OAAO+Q,kBAAmB,EAC1BF,EAAKL,WAAWQ,MAAM/a,UAAW,QAAQ,SAAUgb,EAASC,EAAaC,KAEvED,EAAcN,EAAMM,EAAa,CAC/BE,UAAW,CACTC,SAAS,GAEXC,YAAa,CACXC,OAAQ,CACNC,MAAO,CACLH,SAAS,KAOfI,QAAS,CAAE,KAGAF,QAAU,IAAIhP,SAAQ,SAAUgP,GAC3CA,EAAOG,WAAY,CACzB,IAGS1R,OAAO2R,qBACV3R,OAAO2R,mBAAqBnB,WAAWoB,SAASlE,KAAM,UAAU,KAC9D1N,OAAO+Q,kBAAmB,CAAI,KAIlCE,EAAQ9V,MAAMuS,KAAM,CAACwD,EAAaC,GACtC,IAEEN,EAAKL,WAAWqB,OAAO5b,UAAW,QAAQ,SAAUgb,EAASa,EAAOjU,GAClEoT,EAAQ9V,MAAMuS,KAAM,CAACoE,EAAOjU,GAChC,IAGE,MAAMkU,EAAoB,CACxBD,MAAO,CAELJ,WAAW,EAEXtT,OAAQP,EAAQH,OAAOU,OACvBC,MAAOR,EAAQH,OAAOW,OAExB+S,UAAW,CAETC,SAAS,IAKPH,EAAc,IAAIc,SAAS,UAAUnU,EAAQH,OAAOE,QAAtC,GAGdiB,EAAe,IAAImT,SAAS,UAAUnU,EAAQH,OAAOmB,eAAtC,GAGfD,EAAgB,IAAIoT,SACxB,UAAUnU,EAAQH,OAAOkB,gBADL,GAKhBqT,EAAerB,GACnB,EACA/R,EACAqS,EAEAa,GAIIG,EAAgBrU,EAAQkB,YAAYE,SACtC,IAAI+S,SAAS,UAAUnU,EAAQkB,YAAYE,WAA3C,GACA,KAGApB,EAAQkB,YAAYnF,YACtB,IAAIoY,SAAS,UAAWnU,EAAQkB,YAAYnF,WAA5C,CAAwDsX,GAItDtS,GACF2K,EAAW3K,GAIb4R,WAAW3S,EAAQH,OAAOrH,QAAQ,YAAa4b,EAAcC,GAG7D,MAAMC,EAAiB9I,IAGvB,IAAK,MAAMqB,KAAQyH,EACmB,mBAAzBA,EAAezH,WACjByH,EAAezH,GAK1BnB,EAAWiH,WAAWM,eAGtBN,WAAWM,cAAgB,EAC7B,CC3HA,MAAMsB,SAAWpY,aACftC,KAAKpC,UAAW,YAAa,iBAC7B,QAIF,IAAI+c,QAAU,KAmCP9F,eAAe+F,cAAcC,GAElC,MAAM7Q,MAAEA,EAAKN,MAAEA,GAAUiI,cAGjB9J,OAAQiT,KAAiBC,GAAiB/Q,EAG5CgR,EAAgB,CACpB/Q,UAAUP,EAAMK,kBAAmB,QACnCkR,YAAa,MACb/X,KAAM2X,GAAiB,GACvBK,cAAc,EACdC,eAAe,EACfC,cAAc,EACdC,oBAAoB,EACpBC,gBAAiB,QACbR,GAAgBC,GAItB,IAAKJ,QAAS,CAEZ,IAAIY,EAAW,EAEf,MAAMC,EAAO3G,UACX,IACE5R,IACE,EACA,yDAAyDsY,OAI3DZ,cAAgB5V,UAAU0W,OAAOT,EAClC,CAAC,MAAOnX,GAQP,GAPAD,aACE,EACAC,EACA,oDAIE0X,EAAW,IAOb,MAAM1X,EANNZ,IAAI,EAAG,sCAAsCsY,uBAGvC,IAAIvG,SAASK,GAAaqG,WAAWrG,EAAU,aAC/CmG,GAIT,GAGH,UACQA,IAGyB,UAA3BR,EAAc/Q,UAChBhH,IAAI,EAAG,6CAIL6X,GACF7X,IAAI,EAAG,4CAEV,CAAC,MAAOY,GACP,MAAM,IAAI+R,YACR,gEACA,KACAK,SAASpS,EACZ,CAED,IAAK8W,QACH,MAAM,IAAI/E,YAAY,2CAA4C,IAErE,CAGD,OAAO+E,OACT,CAQO9F,eAAe8G,eAEhBhB,SAAWA,QAAQiB,iBACfjB,QAAQkB,QAEhBlB,QAAU,KACV1X,IAAI,EAAG,gCACT,CAgBO4R,eAAeiH,QAAQC,GAE5B,IAAKpB,UAAYA,QAAQiB,UACvB,MAAM,IAAIhG,YAAY,0CAA2C,KAgBnE,GAZAmG,EAAaC,WAAarB,QAAQmB,gBAG5BC,EAAaC,KAAKC,iBAAgB,SAGlCC,gBAAgBH,EAAaC,MAGnCG,eAAeJ,EAAaC,OAGvBD,EAAaC,MAAQD,EAAaC,KAAKI,WAC1C,MAAM,IAAIxG,YAAY,2CAA4C,IAEtE,CAkBOf,eAAewH,UAAUN,EAAcO,GAAY,GACxD,IACE,GAAIP,EAAaC,OAASD,EAAaC,KAAKI,WAgB1C,OAfIE,SAEIP,EAAaC,KAAKO,KAAK,cAAe,CAC1CC,UAAW,2BAIPN,gBAAgBH,EAAaC,aAG7BD,EAAaC,KAAKS,UAAS,KAC/BC,SAASC,KAAKC,UACZ,4DAA4D,KAG3D,CAEV,CAAC,MAAO/Y,GACPD,aACE,EACAC,EACA,yBAAyBkY,EAAac,mDAIxCd,EAAae,UAAYnL,aAAa7I,KAAKG,UAAY,CACxD,CACD,OAAO,CACT,CAiBO4L,eAAekI,iBAAiBf,EAAMgB,GAE3C,MAAMC,EAAoB,GAGpBzV,EAAYwV,EAAmBxV,UACrC,GAAIA,EAAW,CACb,MAAM0V,EAAa,GAUnB,GAPI1V,EAAU2V,IACZD,EAAW/Y,KAAK,CACdiZ,QAAS5V,EAAU2V,KAKnB3V,EAAU6V,MACZ,IAAK,MAAM9Y,KAAQiD,EAAU6V,MAAO,CAClC,MAAMC,GAAW/Y,EAAKhC,WAAW,QAGjC2a,EAAW/Y,KACTmZ,EACI,CACEF,QAAS9a,aAAanD,gBAAgBoF,GAAO,SAE/C,CACExG,IAAKwG,GAGd,CAGH,IAAK,MAAMgZ,KAAcL,EACvB,IACED,EAAkB9Y,WAAW6X,EAAKwB,aAAaD,GAChD,CAAC,MAAO1Z,GACPD,aAAa,EAAGC,EAAO,8CACxB,CAEHqZ,EAAWnc,OAAS,EAGpB,MAAM0c,EAAc,GACpB,GAAIjW,EAAUkW,IAAK,CACjB,IAAIC,EAAanW,EAAUkW,IAAIE,MAAM,uBACrC,GAAID,EAEF,IAAK,IAAIE,KAAiBF,EACpBE,IACFA,EAAgBA,EACb/e,QAAQ,OAAQ,IAChBA,QAAQ,UAAW,IACnBA,QAAQ,KAAM,IACdA,QAAQ,KAAM,IACdA,QAAQ,IAAK,IACbA,QAAQ,MAAO,IACf0B,OAGCqd,EAActb,WAAW,QAC3Bkb,EAAYtZ,KAAK,CACfpG,IAAK8f,IAEEb,EAAmB7a,oBAC5Bsb,EAAYtZ,KAAK,CACfrE,KAAME,KAAKpC,UAAWigB,MAQhCJ,EAAYtZ,KAAK,CACfiZ,QAAS5V,EAAUkW,IAAI5e,QAAQ,sBAAuB,KAAO,MAG/D,IAAK,MAAMgf,KAAeL,EACxB,IACER,EAAkB9Y,WAAW6X,EAAK+B,YAAYD,GAC/C,CAAC,MAAOja,GACPD,aACE,EACAC,EACA,+CAEH,CAEH4Z,EAAY1c,OAAS,CACtB,CACF,CACD,OAAOkc,CACT,CAeOpI,eAAemJ,mBAAmBhC,EAAMiB,GAC7C,IACE,IAAK,MAAMgB,KAAYhB,QACfgB,EAASC,gBAIXlC,EAAKS,UAAS,KAElB,GAA0B,oBAAf3D,WAA4B,CAErC,MAAMqF,EAAYrF,WAAWsF,OAG7B,GAAIjgB,MAAMC,QAAQ+f,IAAcA,EAAUpd,OAExC,IAAK,MAAMsd,KAAYF,EACrBE,GAAYA,EAASC,UAErBxF,WAAWsF,OAAO/e,OAGvB,CAGD,SAAUkf,GAAmB7B,SAAS8B,qBAAqB,WAErD,IAAMC,GAAkB/B,SAAS8B,qBAAqB,aAElDE,GAAiBhC,SAAS8B,qBAAqB,QAGzD,IAAK,MAAMG,IAAW,IACjBJ,KACAE,KACAC,GAEHC,EAAQC,QACT,GAEJ,CAAC,MAAO/a,GACPD,aAAa,EAAGC,EAAO,8CACxB,CACH,CAYAgR,eAAeqH,gBAAgBF,SAEvBA,EAAK6C,WAAWnE,SAAU,CAAE8B,UAAW,2BAGvCR,EAAKwB,aAAa,CAAE1d,KAAME,KAAK0W,eAAgB,sBAG/CsF,EAAKS,SAAS5D,gBACtB,CAWA,SAASsD,eAAeH,GAEtB,MAAMhS,MAAEA,GAAU2H,aAGlBqK,EAAKzG,GAAG,aAAaV,UAGfmH,EAAKI,UAER,IAICpS,EAAMnC,QAAUmC,EAAMG,iBACxB6R,EAAKzG,GAAG,WAAYvR,IAClBR,QAAQP,IAAI,WAAWe,EAAQyR,SAAS,GAG9C,CC5cA,IAAAqJ,YAAe,IAAM,yXCINC,YAAC3Y,GAAQ,8LAQlB0Y,8EAIE1Y,wCCWDyO,eAAemK,gBAAgBhD,EAAM7V,GAE1C,MAAM8W,EAAoB,GAE1B,IAEE,MAAMgC,EAAgB9Y,EAAQH,OAE9B,IAAIkZ,GAAQ,EACZ,GAAID,EAAc7Y,IAAK,CAIrB,GAHAnD,IAAI,EAAG,mCAGoB,QAAvBgc,EAAchgB,KAChB,OAAOggB,EAAc7Y,IAIvB8Y,GAAQ,QAGFC,UAAUnD,EAAMiD,EAAc7Y,IAC1C,MACMnD,IAAI,EAAG,2CAGDmc,cAAcpD,EAAM7V,GAM5B8W,EAAkB9Y,cACN4Y,iBAAiBf,EAAM7V,EAAQkB,cAI3C,MAAMgY,EAAOH,QACHlD,EAAKS,UAAU7V,IACnB,MAAM0Y,EAAa5C,SAAS6C,cAC1B,sCAIIC,EAAcF,EAAW5Y,OAAO+Y,QAAQ9d,MAAQiF,EAChD8Y,EAAaJ,EAAW3Y,MAAM8Y,QAAQ9d,MAAQiF,EAUpD,OANA8V,SAASC,KAAKgD,MAAMC,KAAOhZ,EAI3B8V,SAASC,KAAKgD,MAAME,OAAS,MAEtB,CACLL,cACAE,aACD,GACA5T,WAAWmT,EAAcrY,cACtBoV,EAAKS,UAAS,KAElB,MAAM+C,YAAEA,EAAWE,WAAEA,GAAepX,OAAOwQ,WAAWsF,OAAO,GAO7D,OAFA1B,SAASC,KAAKgD,MAAMC,KAAO,EAEpB,CACLJ,cACAE,aACD,KAIDI,EAAEA,EAACC,EAAEA,SAAYC,eAAehE,GAGhCiE,EAAiBne,KAAKoe,IAC1Bpe,KAAKqe,KAAKd,EAAKG,aAAeP,EAAcvY,SAIxC0Z,EAAgBte,KAAKoe,IACzBpe,KAAKqe,KAAKd,EAAKK,YAAcT,EAActY,QAU7C,IAAI0Z,EAEJ,aARMrE,EAAKsE,YAAY,CACrB5Z,OAAQuZ,EACRtZ,MAAOyZ,EACPG,kBAAmBrB,EAAQ,EAAIpT,WAAWmT,EAAcrY,SAKlDqY,EAAchgB,MACpB,IAAK,MACHohB,QAAeG,WAAWxE,GAC1B,MACF,IAAK,MACL,IAAK,OACHqE,QAAeI,aACbzE,EACAiD,EAAchgB,KACd,CACE0H,MAAOyZ,EACP1Z,OAAQuZ,EACRH,IACAC,KAEFd,EAAc7X,sBAEhB,MACF,IAAK,MACHiZ,QAAeK,WACb1E,EACAiE,EACAG,EACAnB,EAAc7X,sBAEhB,MACF,QACE,MAAM,IAAIwO,YACR,uCAAuCqJ,EAAchgB,QACrD,KAMN,aADM+e,mBAAmBhC,EAAMiB,GACxBoD,CACR,CAAC,MAAOxc,GAEP,aADMma,mBAAmBhC,EAAMiB,GACxBpZ,CACR,CACH,CAcAgR,eAAesK,UAAUnD,EAAM5V,SACvB4V,EAAK6C,WAAWE,YAAY3Y,GAAM,CACtCoW,UAAW,oBAEf,CAiBA3H,eAAeuK,cAAcpD,EAAM7V,SAC3B6V,EAAKS,SAASxD,YAAa9S,EACnC,CAcA0O,eAAemL,eAAehE,GAC5B,OAAOA,EAAK2E,MAAM,oBAAqBhC,IACrC,MAAMmB,EAAEA,EAACC,EAAEA,EAACpZ,MAAEA,EAAKD,OAAEA,GAAWiY,EAAQiC,wBACxC,MAAO,CACLd,IACAC,IACApZ,QACAD,OAAQ5E,KAAK+e,MAAMna,EAAS,EAAIA,EAAS,KAC1C,GAEL,CAaAmO,eAAe2L,WAAWxE,GACxB,OAAOA,EAAK2E,MACV,gCACChC,GAAYA,EAAQmC,WAEzB,CAkBAjM,eAAe4L,aAAazE,EAAM/c,EAAM8hB,EAAM3Z,GAC5C,OAAO4N,QAAQgM,KAAK,CAClBhF,EAAKiF,WAAW,CACdhiB,OACA8hB,OACAG,SAAU,SACVC,UAAU,EACVC,kBAAkB,EAClBC,uBAAuB,KACV,QAATpiB,EAAiB,CAAEqiB,QAAS,IAAO,CAAA,EAEvCC,eAAwB,OAARtiB,IAElB,IAAI+V,SAAQ,CAACwM,EAAUtM,IACrBwG,YACE,IAAMxG,EAAO,IAAIU,YAAY,wBAAyB,OACtDxO,GAAwB,SAIhC,CAiBAyN,eAAe6L,WAAW1E,EAAMtV,EAAQC,EAAOS,GAE7C,aADM4U,EAAKyF,iBAAiB,UACrBzF,EAAK0F,IAAI,CAEdhb,OAAQA,EAAS,EACjBC,QACAua,SAAU,SACV/Y,QAASf,GAAwB,MAErC,CCpSA,IAAI0B,KAAO,KAGX,MAAM6Y,UAAY,CAChBC,iBAAkB,EAClBC,iBAAkB,EAClBC,eAAgB,EAChBC,eAAgB,EAChBC,mBAAoB,EACpBC,uBAAwB,EACxBC,2BAA4B,EAC5BC,UAAW,EACXC,iBAAkB,GAsBbvN,eAAewN,SACpBC,EAAc3Q,aAAa7I,KAC3B+R,EAAgB,UAGVD,cAAcC,GAEpB,IAME,GALA5X,IACE,EACA,8CAA8Cqf,EAAYvZ,mBAAmBuZ,EAAYtZ,eAGvFF,KAKF,YAJA7F,IACE,EACA,yEAMAqf,EAAYvZ,WAAauZ,EAAYtZ,aACvCsZ,EAAYvZ,WAAauZ,EAAYtZ,YAIvCF,KAAO,IAAIyZ,KAAK,IAEXC,SAASF,GACZtb,IAAKsb,EAAYvZ,WACjB9B,IAAKqb,EAAYtZ,WACjByZ,qBAAsBH,EAAYpZ,eAClCwZ,oBAAqBJ,EAAYnZ,cACjCwZ,qBAAsBL,EAAYlZ,eAClCwZ,kBAAmBN,EAAYjZ,YAC/BwZ,0BAA2BP,EAAYhZ,oBACvCwZ,mBAAoBR,EAAY/Y,eAChCwZ,sBAAsB,IAIxBja,KAAKyM,GAAG,WAAWV,MAAOoJ,IAExB,MAAM+E,QAAoB3G,UAAU4B,GAAU,GAC9Chb,IACE,EACA,yBAAyBgb,EAASpB,gDAAgDmG,KACnF,IAGHla,KAAKyM,GAAG,kBAAkB,CAAC0N,EAAUhF,KACnChb,IACE,EACA,yBAAyBgb,EAASpB,0CAEpCoB,EAASjC,KAAO,IAAI,IAGtB,MAAMkH,EAAmB,GAEzB,IAAK,IAAIvO,EAAI,EAAGA,EAAI2N,EAAYvZ,WAAY4L,IAC1C,IACE,MAAMsJ,QAAiBnV,KAAKqa,UAAUC,QACtCF,EAAiB/e,KAAK8Z,EACvB,CAAC,MAAOpa,GACPD,aAAa,EAAGC,EAAO,+CACxB,CAIHqf,EAAiBrY,SAASoT,IACxBnV,KAAKua,QAAQpF,EAAS,IAGxBhb,IACE,EACA,4BAA2BigB,EAAiBniB,OAAS,SAASmiB,EAAiBniB,oCAAsC,KAExH,CAAC,MAAO8C,GACP,MAAM,IAAI+R,YACR,6DACA,KACAK,SAASpS,EACZ,CACH,CAYOgR,eAAeyO,WAIpB,GAHArgB,IAAI,EAAG,6DAGH6F,KAAM,CAER,IAAK,MAAMya,KAAUza,KAAK0a,KACxB1a,KAAKua,QAAQE,EAAOtF,UAIjBnV,KAAK2a,kBACF3a,KAAKwV,UACXrb,IAAI,EAAG,4CAET6F,KAAO,IACR,OAGK6S,cACR,CAmBO9G,eAAe6O,SAASvd,GAC7B,IAAIwd,EAEJ,IAYE,GAXA1gB,IAAI,EAAG,gDAGL0e,UAAUC,iBAGRjQ,aAAa7I,KAAKb,cACpB2b,eAIG9a,KACH,MAAM,IAAI8M,YACR,uDACA,KAKJ,MAAMiO,EAAiBziB,cAGvB,IACE6B,IAAI,EAAG,qCAGP0gB,QAAqB7a,KAAKqa,UAAUC,QAGhCjd,EAAQyB,OAAOK,cACjBhF,IACE,EACAkD,EAAQ2d,WACJ,wBAAwB3d,EAAQ2d,iBAChC,eACJ,kCAAkCD,SAGvC,CAAC,MAAOhgB,GACP,MAAM,IAAI+R,YACR,WACGzP,EAAQ2d,WAAa,YAAY3d,EAAQ2d,iBAAmB,IAC7D,wDAAwDD,SAC1D,KACA5N,SAASpS,EACZ,CAGD,GAFAZ,IAAI,EAAG,qCAEF0gB,EAAa3H,KAGhB,MADA2H,EAAa7G,UAAY3W,EAAQ2C,KAAKG,UAAY,EAC5C,IAAI2M,YACR,mEACA,KAKJ,MAAMmO,EAAYtjB,iBAElBwC,IACE,EACA,yBAAyB0gB,EAAa9G,2CAIxC,MAAMmH,EAAgB5iB,cAChBif,QAAerB,gBAAgB2E,EAAa3H,KAAM7V,GAGxD,GAAIka,aAAkB/L,MAmBpB,KANuB,0BAAnB+L,EAAOrc,UAET2f,EAAa7G,UAAY3W,EAAQ2C,KAAKG,UAAY,EAClD0a,EAAa3H,KAAO,MAIJ,iBAAhBqE,EAAO1M,MACY,0BAAnB0M,EAAOrc,QAED,IAAI4R,YACR,WACGzP,EAAQ2d,WAAa,YAAY3d,EAAQ2d,iBAAmB,IAC7D,iHACF7N,SAASoK,GAEL,IAAIzK,YACR,WACGzP,EAAQ2d,WAAa,YAAY3d,EAAQ2d,iBAAmB,IAC7D,oCAAoCE,UACtC/N,SAASoK,GAKXla,EAAQyB,OAAOK,cACjBhF,IACE,EACAkD,EAAQ2d,WACJ,wBAAwB3d,EAAQ2d,iBAChC,eACJ,sCAAsCE,UAK1Clb,KAAKua,QAAQM,GAIb,MACMM,EADUxjB,iBACasjB,EAS7B,OAPApC,UAAUQ,WAAa8B,EACvBtC,UAAUS,iBACRT,UAAUQ,YAAcR,UAAUE,iBAEpC5e,IAAI,EAAG,4BAA4BghB,QAG5B,CACL5D,SACAla,UAEH,CAAC,MAAOtC,GAOP,OANE8d,UAAUG,eAER6B,GACF7a,KAAKua,QAAQM,GAGT9f,CACP,CACH,CAqBO,SAASqgB,eACd,OAAOvC,SACT,CAUO,SAASwC,kBACd,MAAO,CACLnd,IAAK8B,KAAK9B,IACVC,IAAK6B,KAAK7B,IACVuc,KAAM1a,KAAKsb,UACXC,UAAWvb,KAAKwb,UAChBC,WAAYzb,KAAKsb,UAAYtb,KAAKwb,UAClCE,gBAAiB1b,KAAK2b,qBACtBC,eAAgB5b,KAAK6b,oBACrBC,mBAAoB9b,KAAK+b,wBACzBC,gBAAiBhc,KAAKgc,gBAAgB/jB,OACtCgkB,YACEjc,KAAKsb,UACLtb,KAAKwb,UACLxb,KAAK2b,qBACL3b,KAAK6b,oBACL7b,KAAK+b,wBACL/b,KAAKgc,gBAAgB/jB,OAE3B,CASO,SAAS6iB,cACd,MAAM5c,IACJA,EAAGC,IACHA,EAAGuc,KACHA,EAAIa,UACJA,EAASE,WACTA,EAAUC,gBACVA,EAAeE,eACfA,EAAcE,mBACdA,EAAkBE,gBAClBA,EAAeC,YACfA,GACEZ,kBAEJlhB,IAAI,EAAG,2DAA2D+D,MAClE/D,IAAI,EAAG,2DAA2DgE,MAClEhE,IAAI,EAAG,wCAAwCugB,MAC/CvgB,IAAI,EAAG,wCAAwCohB,MAC/CphB,IACE,EACA,+DAA+DshB,MAEjEthB,IACE,EACA,0DAA0DuhB,MAE5DvhB,IACE,EACA,yDAAyDyhB,MAE3DzhB,IACE,EACA,2DAA2D2hB,MAE7D3hB,IACE,EACA,2DAA2D6hB,MAE7D7hB,IAAI,EAAG,uCAAuC8hB,KAChD,CAUA,SAASvC,SAASF,GAChB,MAAO,CAcL0C,OAAQnQ,UAEN,MAAMkH,EAAe,CACnBc,GAAIoI,KAEJnI,UAAWhb,KAAKE,MAAMF,KAAKojB,UAAY5C,EAAYrZ,UAAY,KAGjE,IAEE,MAAMkc,EAAY1kB,iBAclB,aAXMqb,QAAQC,GAGd9Y,IACE,EACA,yBAAyB8Y,EAAac,6CACpCpc,iBAAmB0kB,QAKhBpJ,CACR,CAAC,MAAOlY,GAKP,MAJAZ,IACE,EACA,yBAAyB8Y,EAAac,qDAElChZ,CACP,GAgBHuhB,SAAUvQ,MAAOkH,GAiBVA,EAAaC,KASdD,EAAaC,KAAKI,YACpBnZ,IACE,EACA,yBAAyB8Y,EAAac,yDAEjC,GAILd,EAAaC,KAAKqJ,YAAYC,UAChCriB,IACE,EACA,yBAAyB8Y,EAAac,wDAEjC,KAKPyF,EAAYrZ,aACV8S,EAAae,UAAYwF,EAAYrZ,aAEvChG,IACE,EACA,yBAAyB8Y,EAAac,yCAAyCyF,EAAYrZ,yCAEtF,IAlCPhG,IACE,EACA,yBAAyB8Y,EAAac,sDAEjC,GA8CXyB,QAASzJ,MAAOkH,IAMd,GALA9Y,IACE,EACA,yBAAyB8Y,EAAac,8BAGpCd,EAAaC,OAASD,EAAaC,KAAKI,WAC1C,IAEEL,EAAaC,KAAKuJ,mBAAmB,aACrCxJ,EAAaC,KAAKuJ,mBAAmB,WACrCxJ,EAAaC,KAAKuJ,mBAAmB,uBAG/BxJ,EAAaC,KAAKH,OACzB,CAAC,MAAOhY,GAKP,MAJAZ,IACE,EACA,yBAAyB8Y,EAAac,mDAElChZ,CACP,CACF,EAGP,CC1kBO,SAAS2hB,SAAStlB,GAEvB,MAAMoI,EAAS,IAAImd,MAAM,IAAInd,OAM7B,OAHeod,UAAUpd,GAGXkd,SAAStlB,EAAO,CAAEylB,SAAU,CAAC,kBAC7C,CCHA,IAAIre,oBAAqB,EAmBlBuN,eAAe+Q,aAAazf,GAEjC,IAAIA,IAAWA,EAAQH,OAqCrB,MAAM,IAAI4P,YACR,kKACA,WArCIiQ,YAAY1f,GAAS0O,MAAOhR,EAAOiiB,KAEvC,GAAIjiB,EACF,MAAMA,EAIR,MAAM2C,IAAEA,EAAGtH,QAAEA,EAAOD,KAAEA,GAAS6mB,EAAK3f,QAAQH,OAG5C,IACMQ,EAEF2R,cACE,GAAGjZ,EAAQE,MAAM,KAAKC,SAAW,cACjCY,UAAU6lB,EAAKzF,OAAQphB,IAIzBkZ,cACEjZ,GAAW,SAASD,IACX,QAATA,EAAiBkB,OAAOC,KAAK0lB,EAAKzF,OAAQ,UAAYyF,EAAKzF,OAGhE,CAAC,MAAOxc,GACP,MAAM,IAAI+R,YACR,sCACA,KACAK,SAASpS,EACZ,OAGKyf,UAAU,GAQtB,CAqBOzO,eAAekR,YAAY5f,GAEhC,KAAIA,GAAWA,EAAQH,QAAUG,EAAQH,OAAOK,OA4E9C,MAAM,IAAIuP,YACR,+GACA,KA9EmD,CAErD,MAAMoQ,EAAiB,GAGvB,IAAK,IAAIC,KAAQ9f,EAAQH,OAAOK,MAAMjH,MAAM,MAAQ,GAClD6mB,EAAOA,EAAK7mB,MAAM,KACE,IAAhB6mB,EAAKllB,OACPilB,EAAe7hB,KACb0hB,YACE,IACK1f,EACHH,OAAQ,IACHG,EAAQH,OACXC,OAAQggB,EAAK,GACb/mB,QAAS+mB,EAAK,MAGlB,CAACpiB,EAAOiiB,KAEN,GAAIjiB,EACF,MAAMA,EAIR,MAAM2C,IAAEA,EAAGtH,QAAEA,EAAOD,KAAEA,GAAS6mB,EAAK3f,QAAQH,OAG5C,IACMQ,EAEF2R,cACE,GAAGjZ,EAAQE,MAAM,KAAKC,SAAW,cACjCY,UAAU6lB,EAAKzF,OAAQphB,IAIzBkZ,cACEjZ,EACS,QAATD,EACIkB,OAAOC,KAAK0lB,EAAKzF,OAAQ,UACzByF,EAAKzF,OAGd,CAAC,MAAOxc,GACP,MAAM,IAAI+R,YACR,sCACA,KACAK,SAASpS,EACZ,MAKPZ,IAAI,EAAG,uDAKX,MAAMijB,QAAqBlR,QAAQmR,WAAWH,SAGxC1C,WAGN4C,EAAarb,SAAQ,CAACwV,EAAQpN,KAExBoN,EAAO+F,QACTxiB,aACE,EACAyc,EAAO+F,OACP,+BAA+BnT,EAAQ,sCAE1C,GAEP,CAMA,CA8BO4B,eAAegR,YAAY/T,EAAeuU,GAC/C,IAEEpjB,IAAI,EAAG,2CAGP,MAAMkD,EAAUoM,aAAaZ,YAAW,GAAQG,GAG1CmN,EAAgB9Y,EAAQH,OAG9B,GAA6B,OAAzBiZ,EAAchZ,OAAiB,CAGjC,IAAIqgB,EAFJrjB,IAAI,EAAG,mDAGP,IAEEqjB,EAAchkB,aACZnD,gBAAgB8f,EAAchZ,QAC9B,OAEH,CAAC,MAAOpC,GACP,MAAM,IAAI+R,YACR,mDACA,KACAK,SAASpS,EACZ,CAGD,GAAIob,EAAchZ,OAAO5D,SAAS,QAEhC4c,EAAc7Y,IAAMkgB,MACf,KAAIrH,EAAchZ,OAAO5D,SAAS,SAIvC,MAAM,IAAIuT,YACR,kDACA,KAJFqJ,EAAc/Y,MAAQogB,CAMvB,CACF,CAGD,GAA0B,OAAtBrH,EAAc7Y,IAAc,CAC9BnD,IAAI,EAAG,qDAGLihB,eAAejC,uBAGjB,MAAM5B,QAAekG,eACnBf,SAASvG,EAAc7Y,KACvBD,GAOF,QAHE+d,eAAenC,eAGVsE,EAAY,KAAMhG,EAC1B,CAGD,GAA4B,OAAxBpB,EAAc/Y,OAA4C,OAA1B+Y,EAAc9Y,QAAkB,CAClElD,IAAI,EAAG,sDAGLihB,eAAehC,2BAGjB,MAAM7B,QAAemG,mBACnBvH,EAAc/Y,OAAS+Y,EAAc9Y,QACrCA,GAOF,QAHE+d,eAAelC,mBAGVqE,EAAY,KAAMhG,EAC1B,CAGD,OAAOgG,EACL,IAAIzQ,YACF,gJACA,KAGL,CAAC,MAAO/R,GACP,OAAOwiB,EAAYxiB,EACpB,CACH,CASO,SAAS4iB,wBACd,OAAOnf,kBACT,CAUO,SAASof,sBAAsB/kB,GACpC2F,mBAAqB3F,CACvB,CAkBAkT,eAAe0R,eAAeI,EAAexgB,GAE3C,GAC2B,iBAAlBwgB,IACNA,EAAc/O,QAAQ,SAAW,GAAK+O,EAAc/O,QAAQ,UAAY,GAYzE,OAVA3U,IAAI,EAAG,iCAGPkD,EAAQH,OAAOI,IAAMugB,EAGrBxgB,EAAQH,OAAOE,MAAQ,KACvBC,EAAQH,OAAOG,QAAU,KAGlBygB,eAAezgB,GAEtB,MAAM,IAAIyP,YAAY,mCAAoC,IAE9D,CAkBAf,eAAe2R,mBAAmBG,EAAexgB,GAC/ClD,IAAI,EAAG,uCAGP,MAAMsQ,EAAqBL,gBACzByT,GACA,EACAxgB,EAAQkB,YAAYC,oBAItB,GACyB,OAAvBiM,GAC8B,iBAAvBA,IACNA,EAAmBhR,WAAW,OAC9BgR,EAAmBlR,SAAS,KAE7B,MAAM,IAAIuT,YACR,oPACA,KAWJ,OANAzP,EAAQH,OAAOE,MAAQqN,EAGvBpN,EAAQH,OAAOI,IAAM,KAGdwgB,eAAezgB,EACxB,CAcA0O,eAAe+R,eAAezgB,GAC5B,MAAQH,OAAQiZ,EAAe5X,YAAa2V,GAAuB7W,EA+BnE,OA5BA8Y,EAAchgB,KAAOK,QAAQ2f,EAAchgB,KAAMggB,EAAc/f,SAG/D+f,EAAc/f,QAAUF,WAAWigB,EAAchgB,KAAMggB,EAAc/f,SAGrE+D,IACE,EACA,+BAA+B+Z,EAAmB1V,mBAAqB,UAAY,iBAIrFuf,mBAAmB7J,EAAoBA,EAAmB1V,oBAG1Dwf,sBACE7H,EACAjC,EAAmB7a,mBACnB6a,EAAmB1V,oBAIrBnB,EAAQH,OAAS,IACZiZ,KACA8H,eAAe9H,IAIbyE,SAASvd,EAClB,CAoBA,SAAS4gB,eAAe9H,GAEtB,MAAQ7E,MAAO4M,EAActN,UAAWuN,GACtChI,EAAc9Y,SAAW+M,gBAAgB+L,EAAc/Y,SAAU,GAG3DkU,MAAO8M,EAAoBxN,UAAWyN,GAC5CjU,gBAAgB+L,EAAc/X,iBAAkB,GAG1CkT,MAAOgN,EAAmB1N,UAAW2N,GAC3CnU,gBAAgB+L,EAAc9X,gBAAiB,EAM3CP,EAAQlF,YACZI,KAAKmF,IACH,GACAnF,KAAKkF,IACHiY,EAAcrY,OACZqgB,GAAkBrgB,OAClBugB,GAAwBvgB,OACxBygB,GAAuBzgB,OACvBqY,EAAclY,cACd,EACF,IAGJ,GA4BIsY,EAAO,CAAE3Y,OAvBbuY,EAAcvY,QACdugB,GAAkBK,cAClBN,GAActgB,QACdygB,GAAwBG,cACxBJ,GAAoBxgB,QACpB2gB,GAAuBC,cACvBF,GAAmB1gB,QACnBuY,EAAcpY,eACd,IAeqBF,MAXrBsY,EAActY,OACdsgB,GAAkBM,aAClBP,GAAcrgB,OACdwgB,GAAwBI,aACxBL,GAAoBvgB,OACpB0gB,GAAuBE,aACvBH,GAAmBzgB,OACnBsY,EAAcnY,cACd,IAG4BF,SAG9B,IAAK,IAAK4gB,EAAO7lB,KAAUrD,OAAOoU,QAAQ2M,GACxCA,EAAKmI,GACc,iBAAV7lB,GAAsBA,EAAM7C,QAAQ,SAAU,IAAM6C,EAI/D,OAAO0d,CACT,CAkBA,SAASwH,mBAAmB7J,EAAoB1V,GAE9C,GAAIA,EAAoB,CAEtB,GAA4C,iBAAjC0V,EAAmBxV,UAE5BwV,EAAmBxV,UAAYigB,iBAC7BzK,EAAmBxV,UACnBwV,EAAmB7a,oBACnB,QAEG,IAAK6a,EAAmBxV,UAC7B,IAEEwV,EAAmBxV,UAAYigB,iBAC7BnlB,aAAanD,gBAAgB,kBAAmB,QAChD6d,EAAmB7a,oBACnB,EAEH,CAAC,MAAO0B,GACPZ,IAAI,EAAG,4DACR,CAIH,IAEE+Z,EAAmB9a,WAAaD,WAC9B+a,EAAmB9a,WACnB8a,EAAmB7a,mBAEtB,CAAC,MAAO0B,GACPD,aAAa,EAAGC,EAAO,8CAGvBmZ,EAAmB9a,WAAa,IACjC,CAGD,IAEE8a,EAAmBzV,SAAWtF,WAC5B+a,EAAmBzV,SACnByV,EAAmB7a,oBACnB,EAEH,CAAC,MAAO0B,GACPD,aAAa,EAAGC,EAAO,4CAGvBmZ,EAAmBzV,SAAW,IAC/B,CAGG,CAAC,UAAM7D,GAAW3E,SAASie,EAAmB9a,aAChDe,IAAI,EAAG,uDAIL,CAAC,UAAMS,GAAW3E,SAASie,EAAmBzV,WAChDtE,IAAI,EAAG,qDAIL,CAAC,UAAMS,GAAW3E,SAASie,EAAmBxV,YAChDvE,IAAI,EAAG,qDAEb,MAII,GACE+Z,EAAmBzV,UACnByV,EAAmBxV,WACnBwV,EAAmB9a,WAQnB,MALA8a,EAAmBzV,SAAW,KAC9ByV,EAAmBxV,UAAY,KAC/BwV,EAAmB9a,WAAa,KAG1B,IAAI0T,YACR,oGACA,IAIR,CAkBA,SAAS6R,iBACPjgB,EAAY,KACZrF,EACAmF,GAGA,MAAMogB,EAAe,CAAC,KAAM,MAAO,SAEnC,IAAIC,EAAmBngB,EACnBogB,GAAmB,EAGvB,GAAIzlB,GAAsBqF,EAAUnF,SAAS,SAC3C,IACEslB,EAAmBzU,gBACjB5Q,aAAanD,gBAAgBqI,GAAY,SACzC,EACAF,EAER,CAAM,MACA,OAAO,IACR,MAGDqgB,EAAmBzU,gBAAgB1L,GAAW,EAAOF,GAGjDqgB,IAAqBxlB,UAChBwlB,EAAiBtK,MAK5B,IAAK,MAAMwK,KAAYF,EAChBD,EAAa3oB,SAAS8oB,GAEfD,IACVA,GAAmB,UAFZD,EAAiBE,GAO5B,OAAKD,GAKDD,EAAiBtK,QACnBsK,EAAiBtK,MAAQsK,EAAiBtK,MAAM9R,KAAK3K,GAASA,EAAKJ,WAC9DmnB,EAAiBtK,OAASsK,EAAiBtK,MAAMtc,QAAU,WACvD4mB,EAAiBtK,OAKrBsK,GAZE,IAaX,CAmBA,SAASb,sBACP7H,EACA9c,EACAmF,GAGA,CAAC,gBAAiB,gBAAgBuD,SAASid,IACzC,IAEM7I,EAAc6I,KAGd3lB,GACsC,iBAA/B8c,EAAc6I,IACrB7I,EAAc6I,GAAazlB,SAAS,SAGpC4c,EAAc6I,GAAe5U,gBAC3B5Q,aAAanD,gBAAgB8f,EAAc6I,IAAe,SAC1D,EACAxgB,GAIF2X,EAAc6I,GAAe5U,gBAC3B+L,EAAc6I,IACd,EACAxgB,GAIP,CAAC,MAAOzD,GACPD,aACE,EACAC,EACA,iBAAiBikB,yBAInB7I,EAAc6I,GAAe,IAC9B,KAIC,CAAC,UAAMpkB,GAAW3E,SAASkgB,EAAc/X,gBAC3CjE,IAAI,EAAG,0DAIL,CAAC,UAAMS,GAAW3E,SAASkgB,EAAc9X,eAC3ClE,IAAI,EAAG,wDAEX,CCjyBA,MAAM8kB,SAAW,GASV,SAASC,SAASnL,GACvBkL,SAAS5jB,KAAK0Y,EAChB,CAQO,SAASoL,iBACdhlB,IAAI,EAAG,2DACP,IAAK,MAAM4Z,KAAMkL,SACfG,cAAcrL,GACdsL,aAAatL,EAEjB,CCfA,SAASuL,mBAAmBvkB,EAAOwkB,EAAShT,EAAUiT,GAUpD,OARA1kB,aAAa,EAAGC,GAGmB,gBAA/B8N,aAAajI,MAAMC,gBACd9F,EAAMK,MAIRokB,EAAKzkB,EACd,CAYA,SAAS0kB,sBAAsB1kB,EAAOwkB,EAAShT,EAAUiT,GAEvD,MAAMtkB,QAAEA,EAAOE,MAAEA,GAAUL,EAGrBiS,EAAajS,EAAMiS,YAAc,IAGvCT,EAASmT,OAAO1S,GAAY2S,KAAK,CAAE3S,aAAY9R,UAASE,SAC1D,CAOe,SAASwkB,gBAAgBC,GAEtCA,EAAIC,IAAIR,oBAGRO,EAAIC,IAAIL,sBACV,CC1Ce,SAASM,uBACtBF,EACAG,EAAsBnX,aAAa/J,OAAOQ,cAE1C,IAEE,GAAI0gB,EAAoBjhB,OAAQ,CAC9B,MAAMkhB,EACJ,yEAGIC,EAAc,CAClB/hB,IAAK6hB,EAAoBzgB,aAAe,GACxCC,OAAQwgB,EAAoBxgB,QAAU,EACtCC,MAAOugB,EAAoBvgB,OAAS,EACpCC,WAAYsgB,EAAoBtgB,aAAc,EAC9CC,QAASqgB,EAAoBrgB,UAAW,EACxCC,UAAWogB,EAAoBpgB,YAAa,GAI1CsgB,EAAYxgB,YACdmgB,EAAI9gB,OAAO,eAIb,MAAMohB,EAAUC,UAAU,CACxBC,SAA+B,GAArBH,EAAY1gB,OAAc,IAEpCrB,IAAK+hB,EAAY/hB,IAEjBmiB,QAASJ,EAAYzgB,MACrB8gB,QAAS,CAAChB,EAAShT,KACjBA,EAASiU,OAAO,CACdb,KAAM,KACJpT,EAASmT,OAAO,KAAKe,KAAK,CAAEvlB,QAAS+kB,GAAM,EAE7CS,QAAS,KACPnU,EAASmT,OAAO,KAAKe,KAAKR,EAAI,GAEhC,EAEJU,KAAOpB,IAGqB,IAAxBW,EAAYvgB,UACc,IAA1BugB,EAAYtgB,WACZ2f,EAAQqB,MAAMrrB,MAAQ2qB,EAAYvgB,SAClC4f,EAAQqB,MAAMC,eAAiBX,EAAYtgB,YAE3CzF,IAAI,EAAG,2CACA,KAOb0lB,EAAIC,IAAIK,GAERhmB,IACE,EACA,8CAA8C+lB,EAAY/hB,oBAAoB+hB,EAAY1gB,8CAA8C0gB,EAAYxgB,cAEvJ,CACF,CAAC,MAAO3E,GACP,MAAM,IAAI+R,YACR,yEACA,KACAK,SAASpS,EACZ,CACH,CCzFA,MAAM+lB,kBAAkBhU,YAQtB,WAAAC,CAAY7R,EAAS8R,GACnBC,MAAM/R,EAAS8R,EAChB,CASD,SAAA+T,CAAU/T,GAGR,OAFAE,KAAKF,WAAaA,EAEXE,IACR,ECUH,SAAS8T,sBAAsBzB,EAAShT,EAAUiT,GAChD,IAEE,MAAMyB,EAAc1B,EAAQ2B,QAAQ,iBAAmB,GAGvD,IACGD,EAAYhrB,SAAS,sBACrBgrB,EAAYhrB,SAAS,uCACrBgrB,EAAYhrB,SAAS,uBAEtB,MAAM,IAAI6qB,UACR,iHACA,KAKJ,OAAOtB,GACR,CAAC,MAAOzkB,GACP,OAAOykB,EAAKzkB,EACb,CACH,CAmBA,SAASomB,sBAAsB5B,EAAShT,EAAUiT,GAChD,IAEE,MAAM3L,EAAO0L,EAAQ1L,KAGfuN,EAAYjF,KAAOnmB,QAAQ,KAAM,IAGvC,IAAK6d,GAAQ9b,cAAc8b,GAQzB,MAPA1Z,IACE,EACA,yBAAyBinB,yBACvB7B,EAAQ2B,QAAQ,oBAAsB3B,EAAQ8B,WAAWC,2DAIvD,IAAIR,UACR,sKACA,KAKJ,MAAMtiB,EAAqBmf,wBAGrBvgB,EAAQgN,gBAEZyJ,EAAKzW,OAASyW,EAAKxW,SAAWwW,EAAK1W,QAAU0W,EAAKmJ,MAElD,EAEAxe,GAIF,GAAc,OAAVpB,IAAmByW,EAAKvW,IAQ1B,MAPAnD,IACE,EACA,yBAAyBinB,yBACvB7B,EAAQ2B,QAAQ,oBAAsB3B,EAAQ8B,WAAWC,2FACmB9W,KAAKc,UAAUuI,OAGzF,IAAIiN,UACR,iRACA,KAKJ,GAAIjN,EAAKvW,KAAOpF,uBAAuB2b,EAAKvW,KAC1C,MAAM,IAAIwjB,UACR,4LACA,KA0CJ,OArCAvB,EAAQgC,iBAAmB,CAEzBvG,WAAYoG,EACZlkB,OAAQ,CACNE,QACAE,IAAKuW,EAAKvW,IACVlH,QACEyd,EAAKzd,SACL,GAAGmpB,EAAQiC,OAAOC,UAAY,WAAWjrB,QAAQqd,EAAK1d,QACxDA,KAAMK,QAAQqd,EAAK1d,KAAM0d,EAAKzd,SAC9BP,OAAQD,UAAUie,EAAKhe,QACvB6H,IAAKmW,EAAKnW,IACVC,WAAYkW,EAAKlW,WACjBC,OAAQiW,EAAKjW,OACbC,MAAOgW,EAAKhW,MACZC,MAAO+V,EAAK/V,MACZM,cAAegM,gBACbyJ,EAAKzV,eACL,EACAI,GAEFH,aAAc+L,gBACZyJ,EAAKxV,cACL,EACAG,IAGJD,YAAa,CACXC,qBACAnF,oBAAoB,EACpBD,WAAYya,EAAKza,WACjBqF,SAAUoV,EAAKpV,SACfC,UAAW0L,gBAAgByJ,EAAKnV,WAAW,EAAMF,KAK9CghB,GACR,CAAC,MAAOzkB,GACP,OAAOykB,EAAKzkB,EACb,CACH,CAOe,SAAS2mB,qBAAqB7B,GAE3CA,EAAI8B,KAAK,CAAC,IAAK,cAAeX,uBAG9BnB,EAAI8B,KAAK,CAAC,IAAK,cAAeR,sBAChC,CClLA,MAAMS,aAAe,CACnBC,IAAK,YACLC,KAAM,aACNC,IAAK,YACLnJ,IAAK,kBACLtb,IAAK,iBAgBPyO,eAAeiW,cAAczC,EAAShT,EAAUiT,GAC9C,IAEE,MAAMyC,EAAiB3pB,cAGvB,IAAI4pB,GAAoB,EACxB3C,EAAQ4C,OAAO1V,GAAG,SAAU2V,IACtBA,IACFF,GAAoB,EACrB,IAIH,MAAMjW,EAAiBsT,EAAQgC,iBAGzBH,EAAYnV,EAAe+O,WAGjC7gB,IAAI,EAAG,iDAAiDinB,YAGlDrE,YAAY9Q,GAAgB,CAAClR,EAAOiiB,KAKxC,GAHAuC,EAAQ4C,OAAO1F,mBAAmB,SAG9ByF,EACF/nB,IACE,EACA,qBAAqBinB,mFAHzB,CASA,GAAIrmB,EACF,MAAMA,EAIR,IAAKiiB,IAASA,EAAKzF,OASjB,MARApd,IACE,EACA,qBAAqBinB,qBACnB7B,EAAQ2B,QAAQ,oBAChB3B,EAAQ8B,WAAWC,mDACiBtE,EAAKzF,WAGvC,IAAIuJ,UACR,6GACA,KAKJ,GAAI9D,EAAKzF,OAAQ,CACfpd,IACE,EACA,qBAAqBinB,yCAAiDa,UAIxE,MAAM9rB,KAAEA,EAAIuH,IAAEA,EAAGC,WAAEA,EAAUvH,QAAEA,GAAY4mB,EAAK3f,QAAQH,OAGxD,OAAIQ,EACK6O,EAASkU,KAAKtpB,UAAU6lB,EAAKzF,OAAQphB,KAI9CoW,EAAS8V,OAAO,eAAgBT,aAAazrB,IAAS,aAGjDwH,GACH4O,EAAS+V,WAAWlsB,GAIN,QAATD,EACHoW,EAASkU,KAAKzD,EAAKzF,QACnBhL,EAASkU,KAAKppB,OAAOC,KAAK0lB,EAAKzF,OAAQ,WAC5C,CAlDA,CAkDA,GAEJ,CAAC,MAAOxc,GACP,OAAOykB,EAAKzkB,EACb,CACH,CASe,SAASwnB,aAAa1C,GAKnCA,EAAI8B,KAAK,IAAKK,eAMdnC,EAAI8B,KAAK,aAAcK,cACzB,CCpIA,MAAMQ,gBAAkB,IAAI/qB,KAGtBgrB,YAAcjY,KAAK9B,MAAMlP,aAAatC,KAAKpC,UAAW,kBAGtD4tB,aAAe,GAGfC,eAAiB,IAGjBC,WAAa,GAUnB,SAASC,0BACP,OAAOH,aAAa1Y,QAAO,CAAC8Y,EAAGC,IAAMD,EAAIC,GAAG,GAAKL,aAAazqB,MAChE,CAUA,SAAS+qB,oBACP,OAAOC,aAAY,KACjB,MAAMC,EAAQ9H,eACR+H,EACuB,IAA3BD,EAAMpK,iBACF,EACCoK,EAAMnK,iBAAmBmK,EAAMpK,iBAAoB,IAE1D4J,aAAarnB,KAAK8nB,GACdT,aAAazqB,OAAS2qB,YACxBF,aAAansB,OACd,GACAosB,eACL,CASe,SAASS,aAAavD,GAGnCX,SAAS8D,qBAKTnD,EAAIvT,IAAI,WAAW,CAACiT,EAAShT,EAAUiT,KACrC,IACErlB,IAAI,EAAG,qCAEP,MAAM+oB,EAAQ9H,eACRiI,EAASX,aAAazqB,OACtBqrB,EAAgBT,0BAGtBtW,EAASkU,KAAK,CAEZf,OAAQ,KACR6D,SAAUf,gBACVgB,OAAQ,GAAGxqB,KAAKyqB,OAAO9rB,iBAAmB6qB,gBAAgB5qB,WAAa,IAAO,cAG9E8rB,cAAejB,YAAYhmB,QAC3BknB,kBAAmBjV,uBAGnBkV,kBAAmBV,EAAM5J,iBACzBuK,iBAAkBX,EAAMpK,iBACxBgL,iBAAkBZ,EAAMnK,iBACxBgL,cAAeb,EAAMlK,eACrBgL,YAAcd,EAAMnK,iBAAmBmK,EAAMpK,iBAAoB,IAGjE9Y,KAAMqb,kBAGNgI,SACAC,gBACApoB,QACE6H,MAAMugB,KAAmBZ,aAAazqB,OAClC,oEACA,QAAQorB,mCAAwCC,EAAcW,QAAQ,OAG5EC,WAAYhB,EAAMjK,eAClBkL,YAAajB,EAAMhK,mBACnBkL,mBAAoBlB,EAAM/J,uBAC1BkL,oBAAqBnB,EAAM9J,4BAE9B,CAAC,MAAOre,GACP,OAAOykB,EAAKzkB,EACb,IAEL,CC7Ge,SAASupB,SAASzE,GAI/BA,EAAIvT,IAAIzD,aAAanI,GAAGC,OAAS,KAAK,CAAC4e,EAAShT,EAAUiT,KACxD,IACEjT,EAASgY,SAASrtB,KAAKpC,UAAW,SAAU,cAAe,CACzD0vB,cAAc,GAEjB,CAAC,MAAOzpB,GACP,OAAOykB,EAAKzkB,EACb,IAEL,CCbe,SAAS0pB,oBAAoB5E,GAK1CA,EAAI8B,KAAK,+BAA+B5V,MAAOwT,EAAShT,EAAUiT,KAChE,IAEE,MAAMkF,EAAalc,KAAK/E,uBAGxB,IAAKihB,IAAeA,EAAWzsB,OAC7B,MAAM,IAAI6oB,UACR,iHACA,KAKJ,MAAM6D,EAAQpF,EAAQjT,IAAI,WAG1B,IAAKqY,GAASA,IAAUD,EACtB,MAAM,IAAI5D,UACR,2EACA,KAKJ,MAAMlS,EAAa2Q,EAAQiC,OAAO5S,WAClC,IAAIA,EAmBF,MAAM,IAAIkS,UAAU,qCAAsC,KAlB1D,UAEQnS,wBAAwBC,EAC/B,CAAC,MAAO7T,GACP,MAAM,IAAI+lB,UACR,6BAA6B/lB,EAAMG,UACnC,KACAiS,SAASpS,EACZ,CAGDwR,EAASmT,OAAO,KAAKe,KAAK,CACxBzT,WAAY,IACZ2W,kBAAmBjV,uBACnBxT,QAAS,+CAA+C0T,MAM7D,CAAC,MAAO7T,GACP,OAAOykB,EAAKzkB,EACb,IAEL,CCvCA,MAAM6pB,cAAgB,IAAIC,IAGpBhF,IAAMiF,UAqBL/Y,eAAegZ,YAAYC,EAAgBnc,aAAa/J,QAC7D,IAEE,IAAKkmB,EAAcjmB,SAAW8gB,IAC5B,MAAM,IAAI/S,YACR,mFACA,KAMJ,MAAMmY,EAA+C,KAA5BD,EAAc9lB,YAAqB,KAGtDgmB,EAAUC,OAAOC,gBAGjBC,EAASF,OAAO,CACpBD,UACAI,OAAQ,CACNC,UAAWN,KA2Cf,GAtCApF,IAAI2F,QAAQ,gBAGZ3F,IAAIC,IACF2F,KAAK,CACHC,QAAS,CAAC,OAAQ,MAAO,cAM7B7F,IAAIC,KAAI,CAACP,EAAShT,EAAUiT,KAC1BjT,EAASoZ,IAAI,gBAAiB,QAC9BnG,GAAM,IAIRK,IAAIC,IACFgF,QAAQnF,KAAK,CACXiG,MAAOX,KAKXpF,IAAIC,IACFgF,QAAQe,WAAW,CACjBC,UAAU,EACVF,MAAOX,KAKXpF,IAAIC,IAAIuF,EAAOU,QAGflG,IAAIC,IAAIgF,QAAQkB,OAAO9uB,KAAKpC,UAAW,aAGlCkwB,EAAcnlB,IAAIC,MAAO,CAE5B,MAAMmmB,EAAapZ,KAAKqZ,aAAarG,KAGrCsG,2BAA2BF,GAG3BA,EAAWG,OAAOpB,EAAc/lB,KAAM+lB,EAAchmB,MAAM,KAExD4lB,cAAce,IAAIX,EAAc/lB,KAAMgnB,GAEtC9rB,IACE,EACA,mCAAmC6qB,EAAchmB,QAAQgmB,EAAc/lB,QACxE,GAEJ,CAGD,GAAI+lB,EAAcnlB,IAAId,OAAQ,CAE5B,IAAIxJ,EAAK8wB,EAET,IAEE9wB,QAAY+wB,SACVpvB,KAAKb,gBAAgB2uB,EAAcnlB,IAAIE,UAAW,cAClD,QAIFsmB,QAAaC,SACXpvB,KAAKb,gBAAgB2uB,EAAcnlB,IAAIE,UAAW,cAClD,OAEH,CAAC,MAAOhF,GACPZ,IACE,EACA,qDAAqD6qB,EAAcnlB,IAAIE,sDAE1E,CAED,GAAIxK,GAAO8wB,EAAM,CAEf,MAAME,EAAc3Z,MAAMsZ,aAAa,CAAE3wB,MAAK8wB,QAAQxG,KAGtDsG,2BAA2BI,GAG3BA,EAAYH,OAAOpB,EAAcnlB,IAAIZ,KAAM+lB,EAAchmB,MAAM,KAE7D4lB,cAAce,IAAIX,EAAcnlB,IAAIZ,KAAMsnB,GAE1CpsB,IACE,EACA,oCAAoC6qB,EAAchmB,QAAQgmB,EAAcnlB,IAAIZ,QAC7E,GAEJ,CACF,CAGD8gB,uBAAuBF,IAAKmF,EAAc1lB,cAG1CoiB,qBAAqB7B,KAGrBuD,aAAavD,KACb0C,aAAa1C,KACbyE,SAASzE,KACT4E,oBAAoB5E,KAGpBD,gBAAgBC,IACjB,CAAC,MAAO9kB,GACP,MAAM,IAAI+R,YACR,qDACA,KACAK,SAASpS,EACZ,CACH,CAOO,SAASyrB,eAEd,GAAI5B,cAAcrO,KAAO,EAAG,CAC1Bpc,IAAI,EAAG,iCAGP,IAAK,MAAO8E,EAAMH,KAAW8lB,cAC3B9lB,EAAOiU,OAAM,KACX6R,cAAc6B,OAAOxnB,GACrB9E,IAAI,EAAG,mCAAmC8E,KAAQ,GAGvD,CACH,CASO,SAASynB,aACd,OAAO9B,aACT,CASO,SAAS+B,aACd,OAAO7B,OACT,CASO,SAAS8B,SACd,OAAO/G,GACT,CAUO,SAASgH,mBAAmB7G,GACjCD,uBAAuBF,IAAKG,EAC9B,CAUO,SAASF,IAAI9oB,KAAS8vB,GAC3BjH,IAAIC,IAAI9oB,KAAS8vB,EACnB,CAUO,SAASxa,IAAItV,KAAS8vB,GAC3BjH,IAAIvT,IAAItV,KAAS8vB,EACnB,CAUO,SAASnF,KAAK3qB,KAAS8vB,GAC5BjH,IAAI8B,KAAK3qB,KAAS8vB,EACpB,CASA,SAASX,2BAA2BrnB,GAClCA,EAAO2N,GAAG,eAAe,CAAC1R,EAAOonB,KAC/BrnB,aACE,EACAC,EACA,0BAA0BA,EAAMG,+BAElCinB,EAAO3M,SAAS,IAGlB1W,EAAO2N,GAAG,SAAU1R,IAClBD,aAAa,EAAGC,EAAO,0BAA0BA,EAAMG,UAAU,IAGnE4D,EAAO2N,GAAG,cAAe0V,IACvBA,EAAO1V,GAAG,SAAU1R,IAClBD,aAAa,EAAGC,EAAO,0BAA0BA,EAAMG,UAAU,GACjE,GAEN,CAEA,IAAe4D,OAAA,CACbimB,wBACAyB,0BACAE,sBACAC,sBACAC,cACAC,sCACA/G,QACAxT,QACAqV,WCxUK5V,eAAegb,gBAAgBC,SAE9B9a,QAAQmR,WAAW,CAEvB8B,iBAGAqH,eAGAhM,aAIFhiB,QAAQyuB,KAAKD,EACf,CCgBOjb,eAAemb,WAAWle,GAE/B,MAAM3L,EAAUoM,aAAaZ,YAAW,GAAQG,GAGhD4U,sBAAsBvgB,EAAQkB,YAAYC,oBAG1ClD,YAAY+B,EAAQ1D,SAGhB0D,EAAQuD,MAAME,sBAChBqmB,oCAII3Z,oBAAoBnQ,EAAQb,WAAYa,EAAQyB,OAAOM,aAGvDma,SAASlc,EAAQ2C,KAAM3C,EAAQpB,UAAU7B,KACjD,CASA,SAAS+sB,8BACPhtB,IAAI,EAAG,sDAGP3B,QAAQiU,GAAG,QAAS2a,IAClBjtB,IAAI,EAAG,sCAAsCitB,KAAQ,IAIvD5uB,QAAQiU,GAAG,UAAUV,MAAOlB,EAAMuc,KAChCjtB,IAAI,EAAG,iBAAiB0Q,sBAAyBuc,YAC3CL,gBAAgB,EAAE,IAI1BvuB,QAAQiU,GAAG,WAAWV,MAAOlB,EAAMuc,KACjCjtB,IAAI,EAAG,iBAAiB0Q,sBAAyBuc,YAC3CL,gBAAgB,EAAE,IAI1BvuB,QAAQiU,GAAG,UAAUV,MAAOlB,EAAMuc,KAChCjtB,IAAI,EAAG,iBAAiB0Q,sBAAyBuc,YAC3CL,gBAAgB,EAAE,IAI1BvuB,QAAQiU,GAAG,qBAAqBV,MAAOhR,EAAO8P,KAC5C/P,aAAa,EAAGC,EAAO,iBAAiB8P,kBAClCkc,gBAAgB,EAAE,GAE5B,CAEA,IAAe5c,MAAA,CAEbrL,cACAimB,wBAGAlc,sBACAE,sBACAU,0BACAI,gCAGAqd,sBACApK,0BACAG,wBACAF,wBAGAvP,wCAGA+L,kBACAiB,kBAGArgB,QACAW,0BACAY,wBACAC,0CACAC,oCAGAmrB"} \ No newline at end of file +{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/config.js","../lib/fetch.js","../lib/errors/ExportError.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/errors/HttpError.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is 0.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is null.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message. Accepts a variable amount of arguments. Arguments after\r\n * the `level` will be passed directly to `console.log`, and/or will be joined\r\n * and appended to the log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the rest are strings to build a message with.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n *\r\n * @returns {void} Ends the function execution when attempting to log\r\n * information at a higher level than what is allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || error.message;\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message about Zod issues with the validation. Optionally,\r\n * a custom message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - The array of Zod issues.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n */\r\nexport function logZodIssues(newLevel, issues = [], customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage} - the following Zod issues occured:`,\r\n ...issues.map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - Object containing `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (0 = no logging,\r\n * 1 = error, 2 = warning, 3 = notice, 4 = verbose, or 5 = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (level >= 0 && level <= logging.levelsDesc.length) {\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update options for the console logging\r\n logging.toConsole = toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path for the log file.\r\n * @param {string} file - The log file name.\r\n * @param {boolean} toFile - The flag for setting the logging to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update options for the file logging\r\n logging.toFile = toFile;\r\n\r\n // Set the `dest` and `file` only if the file logging is enabled\r\n if (toFile) {\r\n logging.dest = dest;\r\n logging.file = file;\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', 'false', 'undefined', 'null', and ''. The strings\r\n * 'undefined', 'null', and '' will be transformed to null, the string 'true'\r\n * will be transformed to the boolean value true, and 'false' will\r\n * be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', 'false', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The string contains a forbidden value`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be numeric and positive`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be numeric and non-negative`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that contains '\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with '.json' or starts with '{' and ends with '}'`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst config = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .json or .svg`\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .json or .svg`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with '{' and ends with '}`\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with '.json'`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .json `\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with '.log'`\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return (\r\n z\r\n .string()\r\n /// TO DO: Correct\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable()\r\n );\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: config.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: config.version(strictCheck),\r\n cdnUrl: config.cdnUrl(strictCheck),\r\n forceFetch: config.forceFetch(strictCheck),\r\n cachePath: config.cachePath(strictCheck),\r\n coreScripts: config.coreScripts(strictCheck),\r\n moduleScripts: config.moduleScripts(strictCheck),\r\n indicatorScripts: config.indicatorScripts(strictCheck),\r\n customScripts: config.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: config.infile(strictCheck),\r\n instr: config.instr(),\r\n options: config.options(),\r\n svg: config.svg(),\r\n outfile: config.outfile(strictCheck),\r\n type: config.type(strictCheck),\r\n constr: config.constr(strictCheck),\r\n b64: config.b64(strictCheck),\r\n noDownload: config.noDownload(strictCheck),\r\n defaultHeight: config.defaultHeight(strictCheck),\r\n defaultWidth: config.defaultWidth(strictCheck),\r\n defaultScale: config.defaultScale(strictCheck),\r\n height: config.height(strictCheck),\r\n width: config.width(strictCheck),\r\n scale: config.scale(strictCheck),\r\n globalOptions: config.globalOptions(),\r\n themeOptions: config.themeOptions(),\r\n batch: config.batch(false),\r\n rasterizationTimeout: config.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: config.allowCodeExecution(strictCheck),\r\n allowFileResources: config.allowFileResources(strictCheck),\r\n customCode: config.customCode(false),\r\n callback: config.callback(false),\r\n resources: config.resources(strictCheck),\r\n loadConfig: config.loadConfig(false),\r\n createConfig: config.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: config.proxyHost(false),\r\n port: config.proxyPort(strictCheck),\r\n timeout: config.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableRateLimiting(strictCheck),\r\n maxRequests: config.maxRequests(strictCheck),\r\n window: config.window(strictCheck),\r\n delay: config.delay(strictCheck),\r\n trustProxy: config.trustProxy(strictCheck),\r\n skipKey: config.skipKey(false),\r\n skipToken: config.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableSsl(strictCheck),\r\n force: config.sslForce(strictCheck),\r\n port: config.sslPort(strictCheck),\r\n certPath: config.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: config.enableServer(strictCheck).optional(),\r\n host: config.host(strictCheck).optional(),\r\n port: config.port(strictCheck).optional(),\r\n benchmarking: config.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: config.minWorkers(strictCheck),\r\n maxWorkers: config.maxWorkers(strictCheck),\r\n workLimit: config.workLimit(strictCheck),\r\n acquireTimeout: config.acquireTimeout(strictCheck),\r\n createTimeout: config.createTimeout(strictCheck),\r\n destroyTimeout: config.destroyTimeout(strictCheck),\r\n idleTimeout: config.idleTimeout(strictCheck),\r\n createRetryInterval: config.createRetryInterval(strictCheck),\r\n reaperInterval: config.reaperInterval(strictCheck),\r\n benchmarking: config.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: config.logLevel(strictCheck),\r\n file: config.logFile(strictCheck),\r\n dest: config.logDest(strictCheck),\r\n toConsole: config.logToConsole(strictCheck),\r\n toFile: config.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableUi(strictCheck),\r\n route: config.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: config.nodeEnv(strictCheck),\r\n listenToProcessExits: config.listenToProcessExits(strictCheck),\r\n noLogo: config.noLogo(strictCheck),\r\n hardResetPage: config.hardResetPage(strictCheck),\r\n browserShellMode: config.browserShellMode(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableDebug(strictCheck),\r\n headless: config.headless(strictCheck),\r\n devtools: config.devtools(strictCheck),\r\n listenToConsole: config.listenToConsole(strictCheck),\r\n dumpio: config.dumpio(strictCheck),\r\n slowMo: config.slowMo(strictCheck),\r\n debuggingPort: config.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n////\r\n// // Schema for the payload section of options\r\n// const PayloadSchema = () =>\r\n// z\r\n// .object({\r\n// requestId: config.requestId()\r\n// })\r\n// .partial();\r\n////\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n //// payload: PayloadSchema()\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n //// payload: PayloadSchema()\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: config.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: config.version(false),\r\n HIGHCHARTS_CDN_URL: config.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: config.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: config.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: config.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: config.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: config.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: config.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: config.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: config.infile(false),\r\n EXPORT_INSTR: config.instr(),\r\n EXPORT_OPTIONS: config.options(),\r\n EXPORT_SVG: config.svg(),\r\n EXPORT_BATCH: config.batch(false),\r\n EXPORT_OUTFILE: config.outfile(false),\r\n EXPORT_TYPE: config.type(false),\r\n EXPORT_CONSTR: config.constr(false),\r\n EXPORT_B64: config.b64(false),\r\n EXPORT_NO_DOWNLOAD: config.noDownload(false),\r\n EXPORT_HEIGHT: config.height(false),\r\n EXPORT_WIDTH: config.width(false),\r\n EXPORT_SCALE: config.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: config.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: config.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: config.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: config.globalOptions(),\r\n EXPORT_THEME_OPTIONS: config.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: config.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: config.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: config.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: config.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: config.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: config.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: config.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: config.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: config.enableServer(false),\r\n SERVER_HOST: config.host(false),\r\n SERVER_PORT: config.port(false),\r\n SERVER_UPLOAD_LIMIT: config.uploadLimit(false),\r\n SERVER_BENCHMARKING: config.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: config.proxyHost(false),\r\n SERVER_PROXY_PORT: config.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: config.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: config.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: config.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: config.window(false),\r\n SERVER_RATE_LIMITING_DELAY: config.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: config.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: config.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: config.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: config.enableSsl(false),\r\n SERVER_SSL_FORCE: config.sslForce(false),\r\n SERVER_SSL_PORT: config.sslPort(false),\r\n SERVER_SSL_CERT_PATH: config.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: config.minWorkers(false),\r\n POOL_MAX_WORKERS: config.maxWorkers(false),\r\n POOL_WORK_LIMIT: config.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: config.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: config.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: config.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: config.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: config.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: config.reaperInterval(false),\r\n POOL_BENCHMARKING: config.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: config.logLevel(false),\r\n LOGGING_FILE: config.logFile(false),\r\n LOGGING_DEST: config.logDest(false),\r\n LOGGING_TO_CONSOLE: config.logToConsole(false),\r\n LOGGING_TO_FILE: config.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: config.enableUi(false),\r\n UI_ROUTE: config.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: config.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: config.listenToProcessExits(false),\r\n OTHER_NO_LOGO: config.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: config.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: config.browserShellMode(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: config.enableDebug(false),\r\n DEBUG_HEADLESS: config.headless(false),\r\n DEBUG_DEVTOOLS: config.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: config.listenToConsole(false),\r\n DEBUG_DUMPIO: config.dumpio(false),\r\n DEBUG_SLOW_MO: config.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: config.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates a provided option using the specific validator from the config\r\n * object.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of an option to validate.\r\n * @param {any} option - The option to validate.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {any} The parsed and validated option value.\r\n */\r\nexport function validateOption(name, option, strictCheck) {\r\n return config[name](strictCheck).parse(option);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate,\r\n validateOption\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport { envs, looseValidate, strictValidate } from './validation.js';\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n/**\r\n * Gets the reference to the global options of the server instance object\r\n * or its copy.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getReference=true] - Optional parameter to decide whether\r\n * to return the reference to the global options of the server instance object\r\n * or return a copy of it. The default value is true.\r\n *\r\n * @returns {Object} The reference to the global options of the server instance\r\n * object or its copy.\r\n */\r\nexport function getOptions(getReference = true) {\r\n return getReference ? globalOptions : deepCopy(globalOptions);\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server instance, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the first parameter (by default an empty object).\r\n * 5. Options from the CLI.\r\n *\r\n * @function setOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n * @param {boolean} [modifyGlobal=false] - Optional parameter to decide\r\n * whether to update and return the reference to the global options\r\n * of the server instance object or return a copy of it. The default value\r\n * is false.\r\n *\r\n * @returns {Object} The updated general options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setOptions(\r\n customOptions = {},\r\n cliArgs = [],\r\n modifyGlobal = false\r\n) {\r\n // Object for options loaded via the `loadConfig` option\r\n let configOptions = {};\r\n\r\n // Object for options from the CLI\r\n let cliOptions = {};\r\n\r\n // Only for the CLI usage\r\n if (cliArgs.length) {\r\n try {\r\n // Validate options from the custom JSON loaded via the `loadConfig`\r\n configOptions = strictValidate(_loadConfigFile(cliArgs));\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] Custom JSON options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Apply custom options if there are any\r\n if (customOptions && Object.keys(customOptions).length !== 0) {\r\n try {\r\n // Validate custom options provided by the user\r\n customOptions = strictValidate(customOptions);\r\n } catch (error) {\r\n logZodIssues(1, error.issues, '[config] Custom options validation error');\r\n }\r\n }\r\n\r\n // Only for the CLI usage\r\n if (cliArgs.length) {\r\n try {\r\n // Validate options from the CLI\r\n cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n } catch (error) {\r\n logZodIssues(1, error.issues, '[config] CLI options validation error');\r\n }\r\n }\r\n\r\n // Get the reference to the global options object or a copy of the object\r\n const generalOptions = getOptions(modifyGlobal);\r\n\r\n // Update values of the general options with values from each source possible\r\n _updateOptions(\r\n defaultConfig,\r\n generalOptions,\r\n configOptions,\r\n customOptions,\r\n cliOptions\r\n );\r\n\r\n // Return options\r\n return generalOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n // Check if the `newOptions` is a correct object\r\n if (isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key];\r\n }\r\n }\r\n\r\n // Return the result options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (Object.prototype.toString.call(oldOptions) === '[object Object]') {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is false.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is false.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is false.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'))\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg')).toString().bold\r\n .yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n options[name] = Object.prototype.hasOwnProperty.call(item, 'value')\r\n ? item.value\r\n : _initGlobalOptions(item);\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Updates options object with values from various sources, following a specific\r\n * prioritization order. The function checks for values in the following order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The options object that will be updated with values\r\n * from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which may override configuration options.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateOptions(config, options, configOpt, customOpt, cliOpt) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the config entry of a specific option\r\n const entry = config[key];\r\n\r\n // Gather values for the options from every possible source, if exists\r\n const configVal = configOpt && configOpt[key];\r\n const customVal = customOpt && customOpt[key];\r\n const cliVal = cliOpt && cliOpt[key];\r\n\r\n // If the value not found, need to go deeper\r\n if (typeof entry.value === 'undefined') {\r\n _updateOptions(entry, options[key], configVal, customVal, cliVal);\r\n } else {\r\n // If a value from custom JSON options exists, it take precedence\r\n if (configVal !== undefined && configVal !== null) {\r\n options[key] = configVal;\r\n }\r\n\r\n // If a value from environment variables exists, it take precedence\r\n const envVal = envs[entry.envLink];\r\n if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n options[key] = envVal;\r\n }\r\n\r\n // If a value from user options exists, it take precedence\r\n if (customVal !== undefined && customVal !== null) {\r\n options[key] = customVal;\r\n }\r\n\r\n // If a value from CLI options exists, it take precedence\r\n if (cliVal !== undefined && cliVal !== null) {\r\n options[key] = cliVal;\r\n }\r\n }\r\n });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n // Check if the `loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `loadConfig` is present and has a correct value\r\n if (configFileName) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return JSON.parse(readFileSync(getAbsolutePath(configFileName)));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options.\r\n * It may include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n setOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath));\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } = highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (Object.keys(manifest.modules || {}).length !== numberOfModules) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Get the reference to the global options to update to the new version\r\n const options = getOptions();\r\n\r\n // Set to the new version\r\n options.highcharts.version = newVersion;\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is false.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - Object containing `highcharts` options.\r\n * @param {Object} serverProxyOptions - Object containing `server.proxy`\r\n * options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n */\r\nexport async function createChart(options) {\r\n // Get required functions\r\n const { getOptions, merge, setOptions, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override userOptions with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in userOptions when forExport is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: options.export.height,\r\n width: options.export.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${options.export.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${options.export.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(\r\n `return ${options.export.globalOptions}`\r\n )();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = options.customLogic.callback\r\n ? new Function(`return ${options.customLogic.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (options.customLogic.customCode) {\r\n new Function('options', options.customLogic.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[options.export.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is false.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: join(__dirname, cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, options) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n let isSVG = false;\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await _setAsSvg(page, exportOptions.svg);\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await _setAsOptions(page, options);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, options.customLogic))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Sets the specified page's content with provided export input within\r\n * the window context using the `page.setContent` function.\r\n *\r\n * @async\r\n * @function _setAsSvg\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {Promise} A Promise that resolves after the content is set.\r\n */\r\nasync function _setAsSvg(page, svg) {\r\n await page.setContent(svgTemplate(svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n}\r\n\r\n/**\r\n * Sets the options with specified export input and sizes as configuration into\r\n * the `createChart` function within the window context using\r\n * the `page.evaluate` function.\r\n *\r\n * @async\r\n * @function _setAsOptions\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves after the configuration\r\n * is set.\r\n */\r\nasync function _setAsOptions(page, options) {\r\n await page.evaluate(createChart, options);\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { getOptions } from './config.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} [poolOptions=getOptions().pool] - Object containing `pool`\r\n * options. The default value is the global pool options of the export server\r\n * instance.\r\n * @param {Array.} [puppeteerArgs=[]] - Additional arguments\r\n * for Puppeteer launch. The default value is an empty array.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(\r\n poolOptions = getOptions().pool,\r\n puppeteerArgs = []\r\n) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Kills all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves after the workers are\r\n * killed, the pool is destroyed, and the browser is closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (getOptions().pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n options._requestId\r\n ? `[benchmark] Request [${options._requestId}] - `\r\n : '[benchmark] ',\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] ' +\r\n (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n `Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Perform an export on a puppeteer level\r\n const exportCounter = measureTime();\r\n const result = await puppeteerExport(workerHandle.page, options);\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n '[pool] ' +\r\n (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n 'Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.'\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n '[pool] ' +\r\n (options._requestId ? `Request [${options._requestId}] - ` : '') +\r\n `Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n options._requestId\r\n ? `[benchmark] Request [${options._requestId}] - `\r\n : '[benchmark] ',\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - Object containing `pool` options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { getOptions, mergeOptions, isAllowedConfig } from './config.js';\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { killPool, postWork, getPoolStats } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\nimport { strictValidate, validateOption } from './validation.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the image in the provided outfile.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain at least one of the following\r\n * properties: `infile`, `instr`, `options`, or `svg` to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Perform an export\r\n await startExport(options, async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on the information\r\n * in the `batch` option. The `batch` is a string in the following format:\r\n * \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results are saved\r\n * in provided outfiles.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which may be a partial\r\n * or complete set of options. It must contain the `batch` option to generate\r\n * valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n ...options,\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n }\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `customOptions` parameter is an object that\r\n * may be partial or complete set of options. The `endCallback` is called when\r\n * the export is completed, with the `error` object as the first argument\r\n * and the `data` object as the second, which contains the Base64 representation\r\n * of the chart in the `result` property and the full set of export options\r\n * in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing work or upon error occurance of the exporting process. The first\r\n * argument is `error` object and the `data` object is the second, that contains\r\n * the Base64 representation of the chart in the `result` property and the full\r\n * set of export options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(customOptions, endCallback) {\r\n try {\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Merge the custom options into default ones\r\n const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n // Get the export options\r\n const exportOptions = options.export;\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n try {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent, false);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] The `svg` option validation error'\r\n );\r\n throw error;\r\n }\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n try {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent, false);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] The `instr` option validation error'\r\n );\r\n throw error;\r\n }\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The `options` object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // The last strict validation of options right before exporting process\r\n try {\r\n // Validate final options\r\n options = strictValidate(options);\r\n } catch (error) {\r\n logZodIssues(1, error.issues, '[config] Final options validation error');\r\n }\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n *\r\n * @returns {Object} An object containing the calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The object containing `customLogic`\r\n * options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is null.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The object containing `export` options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n startExport,\r\n singleExport,\r\n batchExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} [rateLimitingOptions=getOptions().server.rateLimiting] -\r\n * Object containing `rateLimiting` options. The default value is the global\r\n * rate limiting options of the export server instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(\r\n app,\r\n rateLimitingOptions = getOptions().server.rateLimiting\r\n) {\r\n try {\r\n // Check if the rate limiting is enabled\r\n if (rateLimitingOptions.enable) {\r\n const msg =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n max: rateLimitingOptions.maxRequests || 30,\r\n window: rateLimitingOptions.window || 1,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || false,\r\n skipToken: rateLimitingOptions.skipToken || false\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per windowMs\r\n max: rateOptions.max,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message: msg });\r\n },\r\n default: () => {\r\n response.status(429).send(msg);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== false &&\r\n rateOptions.skipToken !== false &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.max} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport ExportError from './ExportError.js';\r\n\r\n/**\r\n * A custom HTTP error class that extends the `ExportError`. Used to handle\r\n * errors with HTTP status codes.\r\n */\r\nclass HttpError extends ExportError {\r\n /**\r\n * Creates an instance of the `HttpError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super(message, statusCode);\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {HttpError} The updated instance of the `HttpError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default HttpError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n fixConstr,\r\n fixType,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new HttpError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {HttpError} Throws an `HttpError` if the body is not correct.\r\n * @throws {HttpError} Throws an `HttpError` if the chart data from the body\r\n * is not correct.\r\n * @throws {HttpError} Throws an `HttpError` in case of the private range url\r\n * error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid().replace(/-/g, '');\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new HttpError(\r\n \"[validation] The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.\",\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new HttpError(\r\n \"[validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.\",\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new HttpError(\r\n \"[validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.\",\r\n 400\r\n );\r\n }\r\n\r\n try {\r\n // Validate options from the body and store parsed structure in the request\r\n request.validatedOptions = looseValidate({\r\n // Set the created ID as a `_requestId` property in the validated options\r\n _requestId: requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${fixType(body.type)}`,\r\n type: fixType(body.type, body.outfile),\r\n constr: fixConstr(body.constr),\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n });\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] Request options validation error'\r\n );\r\n\r\n throw new HttpError(\r\n 'The provided options are not correct. Please check if your data is of the correct types.',\r\n 400\r\n );\r\n }\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions._requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Got an incoming HTTP request with ID ${requestId}.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new HttpError(\r\n '[export] Unexpected return of the export result from the chart generation. Please check your request data.',\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(readFileSync(join(__dirname, 'package.json')));\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport HttpError from '../../errors/HttpError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new HttpError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new HttpError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n const newVersion = request.params.newVersion;\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new HttpError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new HttpError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { getOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts HTTP or/and HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains all server related properties (see\r\n * the `server` section in the `lib/schemas/config.js` file for a reference).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} [serverOptions=getOptions().server] - Object containing\r\n * `server` options. The default value is the global server options\r\n * of the export server instance.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when the server should not be enabled or when no valid Express app\r\n * is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions = getOptions().server) {\r\n try {\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n healthRoutes(app);\r\n exportRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - Object containing `rateLimiting`\r\n * options.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n rateLimitingMiddleware(app, rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Cleans up function to trigger before ending process for the graceful\r\n * shutdown.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} exitCode - An exit code for the `process.exit()` function.\r\n */\r\nexport async function shutdownCleanUp(exitCode) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n setOptions,\r\n mergeOptions,\r\n mapToNewOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\nimport server, { startServer } from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage. This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} customOptions - The `customOptions` object, which may\r\n * be a partial or complete set of options. If the provided options are partial,\r\n * missing values will be merged with the default general options, retrieved\r\n * using the `getOptions` function.\r\n */\r\nexport async function initExport(customOptions) {\r\n // Get the global options object copy and extend it with the incoming options\r\n const options = mergeOptions(getOptions(false), customOptions);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp(0);\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp(0);\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp(0);\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n server,\r\n startServer,\r\n\r\n // Options\r\n getOptions,\r\n setOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Cache\r\n checkAndUpdateCache,\r\n\r\n // Pool\r\n initPool,\r\n killPool,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n\r\n // Utils\r\n shutdownCleanUp\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","indexOf","object","passthrough","additionalOptions","adminToken","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","isInteger","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","validateOption","name","option","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","_initGlobalOptions","getOptions","getReference","setOptions","customOptions","cliArgs","modifyGlobal","cliOptions","_loadConfigFile","_pairArgumentValue","generalOptions","_updateOptions","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","configOpt","customOpt","cliOpt","configVal","customVal","cliVal","envVal","stringifyFunctions","stringify","replaceAll","Error","configIndex","findIndex","arg","configFileName","i","async","fetch","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","ExportError","constructor","statusCode","super","setError","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","customLogicOptions","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","exportOptions","isSVG","_setAsSvg","_setAsOptions","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","_requestId","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","msg","rateOptions","limiter","rateLimit","windowMs","delayMs","handler","format","send","default","skip","query","access_token","HttpError","setStatus","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","limit","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","_attachProcessExitListeners"],"mappings":"0kBA2BO,MAAMA,UAAYC,cAAc,IAAIC,IAAI,mBAAoBC,MA+B5D,SAASC,SAASC,GAEvB,GAAe,OAAXA,GAAqC,iBAAXA,EAC5B,OAAOA,EAIT,MAAMC,EAAaC,MAAMC,QAAQH,GAAU,GAAK,GAGhD,IAAK,MAAMI,KAAOJ,EACZK,OAAOC,UAAUC,eAAeC,KAAKR,EAAQI,KAC/CH,EAAWG,GAAOL,SAASC,EAAOI,KAKtC,OAAOH,CACT,CA2DO,SAASQ,UAAUC,GACxB,IAEE,MAAMC,EAAc,GAAGD,EAAOE,cAAcC,QAAQ,QAAS,WAQ7D,MALoB,UAAhBF,GACFA,EAAYC,cAIP,CAAC,QAAS,aAAc,WAAY,cAAcE,SACvDH,GAEEA,EACA,OACR,CAAI,MAEA,MAAO,OACR,CACH,CAYO,SAASI,WAAWC,EAAMC,GAO/B,MAAO,GALUC,gBAAgBD,GAAW,SACzCE,MAAM,KACNC,WAGmBJ,GACxB,CAaO,SAASK,QAAQL,EAAMC,EAAU,MAEtC,MAAMK,EAAY,CAChB,YAAa,MACb,aAAc,OACd,kBAAmB,MACnB,gBAAiB,OAIbC,EAAUlB,OAAOmB,OAAOF,GAG9B,GAAIL,EAAS,CACX,MAAMQ,EAAUR,EAAQE,MAAM,KAAKO,MAGnB,QAAZD,EACFT,EAAO,OACEO,EAAQT,SAASW,IAAYT,IAASS,IAC/CT,EAAOS,EAEV,CAGD,OAAOH,EAAUN,IAASO,EAAQI,MAAMC,GAAMA,IAAMZ,KAAS,KAC/D,CAYO,SAASE,gBAAgBW,GAC9B,OAAOC,WAAWD,GAAQA,EAAOE,KAAKpC,UAAWkC,EACnD,CAYO,SAASG,UAAUC,EAAOjB,GAE/B,MAAa,QAATA,GAA0B,OAARA,EACbkB,OAAOC,KAAKF,EAAO,QAAQG,SAAS,UAItCH,CACT,CAOO,SAASI,aAEd,OAAO,IAAIC,MAAOF,WAAWjB,MAAM,KAAK,GAAGoB,MAC7C,CAOO,SAASC,iBACd,OAAO,IAAIF,MAAOG,SACpB,CAWO,SAASC,SAASC,GACvB,MAAgD,oBAAzCtC,OAAOC,UAAU8B,SAAS5B,KAAKmC,EACxC,CAWO,SAASC,cAAcD,GAC5B,MACkB,iBAATA,IACNzC,MAAMC,QAAQwC,IACN,OAATA,GAC6B,IAA7BtC,OAAOwC,KAAKF,GAAMG,MAEtB,CAWO,SAASC,uBAAuBJ,GASrC,MARsB,CACpB,mDACA,uEACA,wEACA,uFACA,qEAGmBK,MAAMC,GAAYA,EAAQC,KAAKP,IACtD,CASO,SAASQ,cACd,MAAMC,EAAQC,QAAQC,OAAOC,SAC7B,MAAO,IAAMC,OAAOH,QAAQC,OAAOC,SAAWH,GAAS,GACzD,CAYO,SAASK,YAAYC,EAAOC,EAAY,GAC7C,MAAMC,EAAaC,KAAKC,IAAI,GAAIH,GAAa,GAC7C,OAAOE,KAAKE,OAAOL,EAAQE,GAAcA,CAC3C,CA6BO,SAASI,WAAWC,EAAYC,EAAoBC,GAAa,GACtE,GAAIF,GAAoC,iBAAfA,EAGvB,OAFAA,EAAaA,EAAW1B,QAET6B,SAAS,OAEfF,EACHF,WACEK,aAAanD,gBAAgB+C,GAAa,QAC1CC,EACAC,GAEF,MAEHA,IACAF,EAAWK,WAAW,eACrBL,EAAWK,WAAW,gBACtBL,EAAWK,WAAW,SACtBL,EAAWK,WAAW,UAGjB,IAAIL,OAINA,EAAWpD,QAAQ,KAAM,GAEpC,CCvXA,MAAM0D,OAAS,CAAC,MAAO,SAAU,OAAQ,OAAQ,SAG3CC,QAAU,CAEdC,WAAW,EACXC,QAAQ,EACRC,aAAa,EAEbC,UAAW,GAEXC,WAAY,CACV,CACEC,MAAO,QACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,UACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,SACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,UACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,YACPC,MAAOR,OAAO,MAkBb,SAASS,OAAOC,GACrB,MAAOC,KAAaC,GAASF,GAGvBJ,WAAEA,EAAUO,MAAEA,GAAUZ,QAG9B,GACe,IAAbU,IACc,IAAbA,GAAkBA,EAAWE,GAASA,EAAQP,EAAW/B,QAE1D,OAIF,MAAMuC,EAAS,GAAGhD,iBAAiBwC,EAAWK,EAAW,GAAGJ,WAGxDN,QAAQE,QACVY,WAAWH,EAAOE,GAIhBb,QAAQC,WACVc,QAAQP,IAAIQ,WACVC,EACA,CAACJ,EAAOjD,WAAWoC,QAAQK,WAAWK,EAAW,GAAGH,QAAQW,OAAOP,GAGzE,CAgBO,SAASQ,aAAaT,EAAUU,EAAOC,GAE5C,MAAMC,EAAcD,GAAiBD,EAAMG,SAGrCX,MAAEA,EAAKP,WAAEA,GAAeL,QAG9B,GAAiB,IAAbU,GAAkBA,EAAWE,GAASA,EAAQP,EAAW/B,OAC3D,OAIF,MAAMuC,EAAS,GAAGhD,iBAAiBwC,EAAWK,EAAW,GAAGJ,WAGtDkB,EAAeJ,EAAMK,MAGrBd,EAAQ,CAACW,GACXE,GACFb,EAAMe,KAAK,KAAMF,GAIfxB,QAAQE,QACVY,WAAWH,EAAOE,GAIhBb,QAAQC,WACVc,QAAQP,IAAIQ,WACVC,EACA,CAACJ,EAAOjD,WAAWoC,QAAQK,WAAWK,EAAW,GAAGH,QAAQW,OAAO,CACjEP,EAAM/D,QAAQmD,OAAOW,EAAW,OAC7BC,IAIX,CAaO,SAASgB,aAAajB,EAAUkB,EAAS,GAAIP,GAClDF,aACET,EACA,KACA,CACE,GAAGW,2CACAO,EAAOC,KAAKC,GAAU,KAAKA,EAAMP,aACpChE,KAAK,MAEX,CASO,SAASwE,YAAYC,GAE1B,MAAMpB,MAAEA,EAAKqB,KAAEA,EAAIC,KAAEA,EAAIjC,UAAEA,EAASC,OAAEA,GAAW8B,EAGjDG,YAAYvB,GAGZwB,qBAAqBnC,GAGrBoC,kBAAkBJ,EAAMC,EAAMhC,EAChC,CAUO,SAASiC,YAAYvB,GACtBA,GAAS,GAAKA,GAASZ,QAAQK,WAAW/B,SAC5C0B,QAAQY,MAAQA,EAEpB,CASO,SAASwB,qBAAqBnC,GAEnCD,QAAQC,UAAYA,CACtB,CAWO,SAASoC,kBAAkBJ,EAAMC,EAAMhC,GAE5CF,QAAQE,OAASA,EAGbA,IACFF,QAAQiC,KAAOA,EACfjC,QAAQkC,KAAOA,EAEnB,CAYA,SAASpB,WAAWH,EAAOE,GACpBb,QAAQG,eAEVmC,WAAW5F,gBAAgBsD,QAAQiC,QAClCM,UAAU7F,gBAAgBsD,QAAQiC,OAGpCjC,QAAQI,UAAY1D,gBAAgBa,KAAKyC,QAAQiC,KAAMjC,QAAQkC,OAI/DlC,QAAQG,aAAc,GAIxBqC,WACExC,QAAQI,UACR,CAACS,GAAQK,OAAOP,GAAOpD,KAAK,KAAO,MAClC6D,IACKA,GAASpB,QAAQE,QAAUF,QAAQG,cACrCH,QAAQE,QAAS,EACjBF,QAAQG,aAAc,EACtBgB,aAAa,EAAGC,EAAO,yCACxB,GAGP,CC3PO,MAAMqB,cAAgB,CAC3BC,UAAW,CACTjC,KAAM,CACJvB,MAAO,CACL,mCACA,kBACA,0CACA,2BACA,kCACA,kCACA,wCACA,2CACA,qBACA,4BACA,2CACA,uDACA,6BACA,yBACA,0BACA,+BACA,uBACA,uFACA,yBACA,oCACA,oBACA,0BACA,8CACA,2BACA,0BACA,6BACA,mCACA,wCACA,mCACA,2BACA,kCACA,uBACA,iBACA,yBACA,8BACA,oBACA,2BACA,eACA,6BACA,iBACA,aACA,eACA,sBACA,cACA,yBACA,oBACA,uBAEFyD,MAAO,CAAC,YACRC,QAAS,iBACTC,QAAS,gBACTC,YAAa,+BACbC,cAAe,CACbvG,KAAM,OACNwG,UAAW,OAIjBC,WAAY,CACVC,QAAS,CACPhE,MAAO,SACPyD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbvG,KAAM,SAGV2G,OAAQ,CACNjE,MAAO,8BACPyD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbvG,KAAM,SAGV4G,WAAY,CACVlE,OAAO,EACPyD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbvG,KAAM,WAGV6G,UAAW,CACTnE,MAAO,SACPyD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbvG,KAAM,SAGV8G,YAAa,CACXpE,MAAO,CAAC,aAAc,kBAAmB,iBACzCyD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbvG,KAAM,cACN+G,aAAc,0DAGlBC,cAAe,CACbtE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,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"} \ No newline at end of file From 9116fd9c4f7c71eefccd12e73aa29299ce28e4c6 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:29:35 +0100 Subject: [PATCH 07/19] Added option to enable or disable validation of options. --- .env.sample | 1 + lib/schemas/config.js | 9 +++++++++ 2 files changed, 10 insertions(+) diff --git a/.env.sample b/.env.sample index 02b80816..35f24371 100644 --- a/.env.sample +++ b/.env.sample @@ -98,6 +98,7 @@ OTHER_LISTEN_TO_PROCESS_EXITS = true OTHER_NO_LOGO = false OTHER_HARD_RESET_PAGE = false OTHER_BROWSER_SHELL_MODE = true +OTHER_VALIDATION = true # DEBUG CONFIG DEBUG_ENABLE = false diff --git a/lib/schemas/config.js b/lib/schemas/config.js index 1c44f1b7..0a141b0e 100644 --- a/lib/schemas/config.js +++ b/lib/schemas/config.js @@ -919,6 +919,15 @@ export const defaultConfig = { promptOptions: { type: 'toggle' } + }, + validation: { + value: true, + types: ['boolean'], + envLink: 'OTHER_VALIDATION', + description: 'Whether or not to enable validation of options types', + promptOptions: { + type: 'toggle' + } } }, debug: { From ac2159472f608ca214d48c6205c07abef8dce37a Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:30:10 +0100 Subject: [PATCH 08/19] Updates of validators in the validation module. --- lib/validation.js | 451 +++++++++++++++++++++++----------------------- 1 file changed, 224 insertions(+), 227 deletions(-) diff --git a/lib/validation.js b/lib/validation.js index 3dc02fc2..02d2ec10 100644 --- a/lib/validation.js +++ b/lib/validation.js @@ -61,10 +61,10 @@ const v = { * validator. * * - When `strictCheck` is false, the schema will accept values are true, - * false, null, 'true', 'false', 'undefined', 'null', and ''. The strings - * 'undefined', 'null', and '' will be transformed to null, the string 'true' - * will be transformed to the boolean value true, and 'false' will - * be transformed to the boolean value false. + * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''. + * The strings 'undefined', 'null', and '' will be transformed to null, + * the string 'true' will be transformed to the boolean value true, + * and 'false' will be transformed to the boolean value false. * * @function boolean * @@ -79,10 +79,10 @@ const v = { : z .union([ z - .enum(['true', 'false', 'undefined', 'null', '']) + .enum(['true', '1', 'false', '0', 'undefined', 'null', '']) .transform((value) => !['undefined', 'null', ''].includes(value) - ? value === 'true' + ? value === 'true' || value === '1' : null ), z.boolean() @@ -119,7 +119,7 @@ const v = { (value) => !['false', 'undefined', 'null', ''].includes(value), { params: { - errorMessage: `The string contains a forbidden value` + errorMessage: 'The string contains a forbidden value' } } ) @@ -254,7 +254,7 @@ const v = { ['undefined', 'null', ''].includes(value), { params: { - errorMessage: `The value must be numeric and positive` + errorMessage: 'The value must be numeric and positive' } } ) @@ -305,7 +305,7 @@ const v = { ['undefined', 'null', ''].includes(value), { params: { - errorMessage: `The value must be numeric and non-negative` + errorMessage: 'The value must be numeric and non-negative' } } ) @@ -399,13 +399,12 @@ const v = { .trim() .refine( (value) => - value.indexOf('= 0 || - value.indexOf('= 0 || (value.startsWith('{') && value.endsWith('}')) || ['undefined', 'null', ''].includes(value), { params: { - errorMessage: `The value must be a string that contains '= 5 && value.endsWith('.svg')), { params: { - errorMessage: `The value must be a string that ends with .json or .svg` + errorMessage: + 'The value must be a string that ends with .json or .svg' } } ) @@ -752,7 +753,8 @@ const config = { ['undefined', 'null', ''].includes(value), { params: { - errorMessage: `The value must be a string that ends with .json or .svg` + errorMessage: + 'The value must be a string that ends with .json or .svg' } } ) @@ -815,7 +817,8 @@ const config = { ['false', 'undefined', 'null', ''].includes(value), { params: { - errorMessage: `The value must be a string that contains '= 6 && value.endsWith('.json')), { params: { - errorMessage: `The value must be a string that starts with '{' and ends with '}` + errorMessage: + "The value must be a string that starts with '{' and ends with '}" } } ); @@ -1315,7 +1321,7 @@ const config = { ['undefined', 'null', ''].includes(value), { params: { - errorMessage: `The value must be a string that ends with '.json'` + errorMessage: 'The value must be a string that ends with .json' } } ) @@ -1351,7 +1357,7 @@ const config = { value === null || (value.length >= 6 && value.endsWith('.json')), { params: { - errorMessage: `The value must be a string that ends with .json ` + errorMessage: 'The value must be a string that ends with .json' } } ); @@ -2006,7 +2012,7 @@ const config = { value === null || (value.length >= 5 && value.endsWith('.log')), { params: { - errorMessage: `The value must be a string that ends with '.log'` + errorMessage: 'The value must be a string that ends with .log' } } ); @@ -2192,6 +2198,24 @@ const config = { return v.boolean(strictCheck); }, + /** + * The `validation` validator that returns a Zod schema with an optional + * stricter check based on the `strictCheck` parameter. + * + * The validation schema ensures the same work as the `boolean` validator. + * + * @function validation + * + * @param {boolean} strictCheck - Determines if stricter validation should + * be applied. + * + * @returns {z.ZodSchema} A Zod schema object for validating the `validation` + * option. + */ + validation(strictCheck) { + return v.boolean(strictCheck); + }, + /** * The `enableDebug` validator that returns a Zod schema with an optional * stricter check based on the `strictCheck` parameter. @@ -2336,13 +2360,10 @@ const config = { * option. */ requestId() { - return ( - z - .string() - /// TO DO: Correct - .uuid({ message: 'The value must be a stringified UUID' }) - .nullable() - ); + return z + .string() + .uuid({ message: 'The value must be a stringified UUID' }) + .nullable(); } }; @@ -2350,7 +2371,7 @@ const config = { const PuppeteerSchema = (strictCheck) => z .object({ - args: config.args(strictCheck) + args: validators.args(strictCheck) }) .partial(); @@ -2358,14 +2379,14 @@ const PuppeteerSchema = (strictCheck) => const HighchartsSchema = (strictCheck) => z .object({ - version: config.version(strictCheck), - cdnUrl: config.cdnUrl(strictCheck), - forceFetch: config.forceFetch(strictCheck), - cachePath: config.cachePath(strictCheck), - coreScripts: config.coreScripts(strictCheck), - moduleScripts: config.moduleScripts(strictCheck), - indicatorScripts: config.indicatorScripts(strictCheck), - customScripts: config.customScripts(strictCheck) + version: validators.version(strictCheck), + cdnUrl: validators.cdnUrl(strictCheck), + forceFetch: validators.forceFetch(strictCheck), + cachePath: validators.cachePath(strictCheck), + coreScripts: validators.coreScripts(strictCheck), + moduleScripts: validators.moduleScripts(strictCheck), + indicatorScripts: validators.indicatorScripts(strictCheck), + customScripts: validators.customScripts(strictCheck) }) .partial(); @@ -2373,25 +2394,25 @@ const HighchartsSchema = (strictCheck) => const ExportSchema = (strictCheck) => z .object({ - infile: config.infile(strictCheck), - instr: config.instr(), - options: config.options(), - svg: config.svg(), - outfile: config.outfile(strictCheck), - type: config.type(strictCheck), - constr: config.constr(strictCheck), - b64: config.b64(strictCheck), - noDownload: config.noDownload(strictCheck), - defaultHeight: config.defaultHeight(strictCheck), - defaultWidth: config.defaultWidth(strictCheck), - defaultScale: config.defaultScale(strictCheck), - height: config.height(strictCheck), - width: config.width(strictCheck), - scale: config.scale(strictCheck), - globalOptions: config.globalOptions(), - themeOptions: config.themeOptions(), - batch: config.batch(false), - rasterizationTimeout: config.rasterizationTimeout(strictCheck) + infile: validators.infile(strictCheck), + instr: validators.instr(), + options: validators.options(), + svg: validators.svg(), + outfile: validators.outfile(strictCheck), + type: validators.type(strictCheck), + constr: validators.constr(strictCheck), + b64: validators.b64(strictCheck), + noDownload: validators.noDownload(strictCheck), + defaultHeight: validators.defaultHeight(strictCheck), + defaultWidth: validators.defaultWidth(strictCheck), + defaultScale: validators.defaultScale(strictCheck), + height: validators.height(strictCheck), + width: validators.width(strictCheck), + scale: validators.scale(strictCheck), + globalOptions: validators.globalOptions(), + themeOptions: validators.themeOptions(), + batch: validators.batch(false), + rasterizationTimeout: validators.rasterizationTimeout(strictCheck) }) .partial(); @@ -2399,13 +2420,13 @@ const ExportSchema = (strictCheck) => const CustomLogicSchema = (strictCheck) => z .object({ - allowCodeExecution: config.allowCodeExecution(strictCheck), - allowFileResources: config.allowFileResources(strictCheck), - customCode: config.customCode(false), - callback: config.callback(false), - resources: config.resources(strictCheck), - loadConfig: config.loadConfig(false), - createConfig: config.createConfig(false) + allowCodeExecution: validators.allowCodeExecution(strictCheck), + allowFileResources: validators.allowFileResources(strictCheck), + customCode: validators.customCode(false), + callback: validators.callback(false), + resources: validators.resources(strictCheck), + loadConfig: validators.loadConfig(false), + createConfig: validators.createConfig(false) }) .partial(); @@ -2413,9 +2434,9 @@ const CustomLogicSchema = (strictCheck) => const ProxySchema = (strictCheck) => z .object({ - host: config.proxyHost(false), - port: config.proxyPort(strictCheck), - timeout: config.proxyTimeout(strictCheck) + host: validators.proxyHost(false), + port: validators.proxyPort(strictCheck), + timeout: validators.proxyTimeout(strictCheck) }) .partial(); @@ -2423,13 +2444,13 @@ const ProxySchema = (strictCheck) => const RateLimitingSchema = (strictCheck) => z .object({ - enable: config.enableRateLimiting(strictCheck), - maxRequests: config.maxRequests(strictCheck), - window: config.window(strictCheck), - delay: config.delay(strictCheck), - trustProxy: config.trustProxy(strictCheck), - skipKey: config.skipKey(false), - skipToken: config.skipToken(false) + enable: validators.enableRateLimiting(strictCheck), + maxRequests: validators.maxRequests(strictCheck), + window: validators.window(strictCheck), + delay: validators.delay(strictCheck), + trustProxy: validators.trustProxy(strictCheck), + skipKey: validators.skipKey(false), + skipToken: validators.skipToken(false) }) .partial(); @@ -2437,20 +2458,21 @@ const RateLimitingSchema = (strictCheck) => const SslSchema = (strictCheck) => z .object({ - enable: config.enableSsl(strictCheck), - force: config.sslForce(strictCheck), - port: config.sslPort(strictCheck), - certPath: config.sslCertPath(false) + enable: validators.enableSsl(strictCheck), + force: validators.sslForce(strictCheck), + port: validators.sslPort(strictCheck), + certPath: validators.sslCertPath(false) }) .partial(); // Schema for the server section of options const ServerSchema = (strictCheck) => z.object({ - enable: config.enableServer(strictCheck).optional(), - host: config.host(strictCheck).optional(), - port: config.port(strictCheck).optional(), - benchmarking: config.serverBenchmarking(strictCheck).optional(), + enable: validators.enableServer(strictCheck).optional(), + host: validators.host(strictCheck).optional(), + port: validators.port(strictCheck).optional(), + uploadLimit: validators.uploadLimit(strictCheck).optional(), + benchmarking: validators.serverBenchmarking(strictCheck).optional(), proxy: ProxySchema(strictCheck).optional(), rateLimiting: RateLimitingSchema(strictCheck).optional(), ssl: SslSchema(strictCheck).optional() @@ -2460,16 +2482,16 @@ const ServerSchema = (strictCheck) => const PoolSchema = (strictCheck) => z .object({ - minWorkers: config.minWorkers(strictCheck), - maxWorkers: config.maxWorkers(strictCheck), - workLimit: config.workLimit(strictCheck), - acquireTimeout: config.acquireTimeout(strictCheck), - createTimeout: config.createTimeout(strictCheck), - destroyTimeout: config.destroyTimeout(strictCheck), - idleTimeout: config.idleTimeout(strictCheck), - createRetryInterval: config.createRetryInterval(strictCheck), - reaperInterval: config.reaperInterval(strictCheck), - benchmarking: config.poolBenchmarking(strictCheck) + minWorkers: validators.minWorkers(strictCheck), + maxWorkers: validators.maxWorkers(strictCheck), + workLimit: validators.workLimit(strictCheck), + acquireTimeout: validators.acquireTimeout(strictCheck), + createTimeout: validators.createTimeout(strictCheck), + destroyTimeout: validators.destroyTimeout(strictCheck), + idleTimeout: validators.idleTimeout(strictCheck), + createRetryInterval: validators.createRetryInterval(strictCheck), + reaperInterval: validators.reaperInterval(strictCheck), + benchmarking: validators.poolBenchmarking(strictCheck) }) .partial(); @@ -2477,11 +2499,11 @@ const PoolSchema = (strictCheck) => const LoggingSchema = (strictCheck) => z .object({ - level: config.logLevel(strictCheck), - file: config.logFile(strictCheck), - dest: config.logDest(strictCheck), - toConsole: config.logToConsole(strictCheck), - toFile: config.logToFile(strictCheck) + level: validators.logLevel(strictCheck), + file: validators.logFile(strictCheck), + dest: validators.logDest(strictCheck), + toConsole: validators.logToConsole(strictCheck), + toFile: validators.logToFile(strictCheck) }) .partial(); @@ -2489,8 +2511,8 @@ const LoggingSchema = (strictCheck) => const UiSchema = (strictCheck) => z .object({ - enable: config.enableUi(strictCheck), - route: config.uiRoute(strictCheck) + enable: validators.enableUi(strictCheck), + route: validators.uiRoute(strictCheck) }) .partial(); @@ -2498,11 +2520,12 @@ const UiSchema = (strictCheck) => const OtherSchema = (strictCheck) => z .object({ - nodeEnv: config.nodeEnv(strictCheck), - listenToProcessExits: config.listenToProcessExits(strictCheck), - noLogo: config.noLogo(strictCheck), - hardResetPage: config.hardResetPage(strictCheck), - browserShellMode: config.browserShellMode(strictCheck) + nodeEnv: validators.nodeEnv(strictCheck), + listenToProcessExits: validators.listenToProcessExits(strictCheck), + noLogo: validators.noLogo(strictCheck), + hardResetPage: validators.hardResetPage(strictCheck), + browserShellMode: validators.browserShellMode(strictCheck), + validation: validators.validation(strictCheck) }) .partial(); @@ -2510,28 +2533,19 @@ const OtherSchema = (strictCheck) => const DebugSchema = (strictCheck) => z .object({ - enable: config.enableDebug(strictCheck), - headless: config.headless(strictCheck), - devtools: config.devtools(strictCheck), - listenToConsole: config.listenToConsole(strictCheck), - dumpio: config.dumpio(strictCheck), - slowMo: config.slowMo(strictCheck), - debuggingPort: config.debuggingPort(strictCheck) + enable: validators.enableDebug(strictCheck), + headless: validators.headless(strictCheck), + devtools: validators.devtools(strictCheck), + listenToConsole: validators.listenToConsole(strictCheck), + dumpio: validators.dumpio(strictCheck), + slowMo: validators.slowMo(strictCheck), + debuggingPort: validators.debuggingPort(strictCheck) }) .partial(); -//// -// // Schema for the payload section of options -// const PayloadSchema = () => -// z -// .object({ -// requestId: config.requestId() -// }) -// .partial(); -//// - // Strict schema for the config export const StrictConfigSchema = z.object({ + requestId: validators.requestId(), puppeteer: PuppeteerSchema(true), highcharts: HighchartsSchema(true), export: ExportSchema(true), @@ -2542,11 +2556,11 @@ export const StrictConfigSchema = z.object({ ui: UiSchema(true), other: OtherSchema(true), debug: DebugSchema(true) - //// payload: PayloadSchema() }); // Loose schema for the config export const LooseConfigSchema = z.object({ + requestId: validators.requestId(), puppeteer: PuppeteerSchema(false), highcharts: HighchartsSchema(false), export: ExportSchema(false), @@ -2557,120 +2571,120 @@ export const LooseConfigSchema = z.object({ ui: UiSchema(false), other: OtherSchema(false), debug: DebugSchema(false) - //// payload: PayloadSchema() }); // Schema for the environment variables config export const EnvSchema = z.object({ // puppeteer - PUPPETEER_ARGS: config.args(false), + PUPPETEER_ARGS: validators.args(false), // highcharts - HIGHCHARTS_VERSION: config.version(false), - HIGHCHARTS_CDN_URL: config.cdnUrl(false), - HIGHCHARTS_FORCE_FETCH: config.forceFetch(false), - HIGHCHARTS_CACHE_PATH: config.cachePath(false), - HIGHCHARTS_ADMIN_TOKEN: config.adminToken(false), - HIGHCHARTS_CORE_SCRIPTS: config.coreScripts(false), - HIGHCHARTS_MODULE_SCRIPTS: config.moduleScripts(false), - HIGHCHARTS_INDICATOR_SCRIPTS: config.indicatorScripts(false), - HIGHCHARTS_CUSTOM_SCRIPTS: config.customScripts(false), + HIGHCHARTS_VERSION: validators.version(false), + HIGHCHARTS_CDN_URL: validators.cdnUrl(false), + HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false), + HIGHCHARTS_CACHE_PATH: validators.cachePath(false), + HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false), + HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false), + HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false), + HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false), + HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false), // export - EXPORT_INFILE: config.infile(false), - EXPORT_INSTR: config.instr(), - EXPORT_OPTIONS: config.options(), - EXPORT_SVG: config.svg(), - EXPORT_BATCH: config.batch(false), - EXPORT_OUTFILE: config.outfile(false), - EXPORT_TYPE: config.type(false), - EXPORT_CONSTR: config.constr(false), - EXPORT_B64: config.b64(false), - EXPORT_NO_DOWNLOAD: config.noDownload(false), - EXPORT_HEIGHT: config.height(false), - EXPORT_WIDTH: config.width(false), - EXPORT_SCALE: config.scale(false), - EXPORT_DEFAULT_HEIGHT: config.defaultHeight(false), - EXPORT_DEFAULT_WIDTH: config.defaultWidth(false), - EXPORT_DEFAULT_SCALE: config.defaultScale(false), - EXPORT_GLOBAL_OPTIONS: config.globalOptions(), - EXPORT_THEME_OPTIONS: config.themeOptions(), - EXPORT_RASTERIZATION_TIMEOUT: config.rasterizationTimeout(false), + EXPORT_INFILE: validators.infile(false), + EXPORT_INSTR: validators.instr(), + EXPORT_OPTIONS: validators.options(), + EXPORT_SVG: validators.svg(), + EXPORT_BATCH: validators.batch(false), + EXPORT_OUTFILE: validators.outfile(false), + EXPORT_TYPE: validators.type(false), + EXPORT_CONSTR: validators.constr(false), + EXPORT_B64: validators.b64(false), + EXPORT_NO_DOWNLOAD: validators.noDownload(false), + EXPORT_HEIGHT: validators.height(false), + EXPORT_WIDTH: validators.width(false), + EXPORT_SCALE: validators.scale(false), + EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false), + EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false), + EXPORT_DEFAULT_SCALE: validators.defaultScale(false), + EXPORT_GLOBAL_OPTIONS: validators.globalOptions(), + EXPORT_THEME_OPTIONS: validators.themeOptions(), + EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false), // custom - CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: config.allowCodeExecution(false), - CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: config.allowFileResources(false), - CUSTOM_LOGIC_CUSTOM_CODE: config.customCode(false), - CUSTOM_LOGIC_CALLBACK: config.callback(false), - CUSTOM_LOGIC_RESOURCES: config.resources(false), - CUSTOM_LOGIC_LOAD_CONFIG: config.loadConfig(false), - CUSTOM_LOGIC_CREATE_CONFIG: config.createConfig(false), + CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false), + CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false), + CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false), + CUSTOM_LOGIC_CALLBACK: validators.callback(false), + CUSTOM_LOGIC_RESOURCES: validators.resources(false), + CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false), + CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false), // server - SERVER_ENABLE: config.enableServer(false), - SERVER_HOST: config.host(false), - SERVER_PORT: config.port(false), - SERVER_UPLOAD_LIMIT: config.uploadLimit(false), - SERVER_BENCHMARKING: config.serverBenchmarking(false), + SERVER_ENABLE: validators.enableServer(false), + SERVER_HOST: validators.host(false), + SERVER_PORT: validators.port(false), + SERVER_UPLOAD_LIMIT: validators.uploadLimit(false), + SERVER_BENCHMARKING: validators.serverBenchmarking(false), // server proxy - SERVER_PROXY_HOST: config.proxyHost(false), - SERVER_PROXY_PORT: config.proxyPort(false), - SERVER_PROXY_TIMEOUT: config.proxyTimeout(false), + SERVER_PROXY_HOST: validators.proxyHost(false), + SERVER_PROXY_PORT: validators.proxyPort(false), + SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false), // server rate limiting - SERVER_RATE_LIMITING_ENABLE: config.enableRateLimiting(false), - SERVER_RATE_LIMITING_MAX_REQUESTS: config.maxRequests(false), - SERVER_RATE_LIMITING_WINDOW: config.window(false), - SERVER_RATE_LIMITING_DELAY: config.delay(false), - SERVER_RATE_LIMITING_TRUST_PROXY: config.trustProxy(false), - SERVER_RATE_LIMITING_SKIP_KEY: config.skipKey(false), - SERVER_RATE_LIMITING_SKIP_TOKEN: config.skipToken(false), + SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false), + SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false), + SERVER_RATE_LIMITING_WINDOW: validators.window(false), + SERVER_RATE_LIMITING_DELAY: validators.delay(false), + SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false), + SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false), + SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false), // server ssl - SERVER_SSL_ENABLE: config.enableSsl(false), - SERVER_SSL_FORCE: config.sslForce(false), - SERVER_SSL_PORT: config.sslPort(false), - SERVER_SSL_CERT_PATH: config.sslCertPath(false), + SERVER_SSL_ENABLE: validators.enableSsl(false), + SERVER_SSL_FORCE: validators.sslForce(false), + SERVER_SSL_PORT: validators.sslPort(false), + SERVER_SSL_CERT_PATH: validators.sslCertPath(false), // pool - POOL_MIN_WORKERS: config.minWorkers(false), - POOL_MAX_WORKERS: config.maxWorkers(false), - POOL_WORK_LIMIT: config.workLimit(false), - POOL_ACQUIRE_TIMEOUT: config.acquireTimeout(false), - POOL_CREATE_TIMEOUT: config.createTimeout(false), - POOL_DESTROY_TIMEOUT: config.destroyTimeout(false), - POOL_IDLE_TIMEOUT: config.idleTimeout(false), - POOL_CREATE_RETRY_INTERVAL: config.createRetryInterval(false), - POOL_REAPER_INTERVAL: config.reaperInterval(false), - POOL_BENCHMARKING: config.poolBenchmarking(false), + POOL_MIN_WORKERS: validators.minWorkers(false), + POOL_MAX_WORKERS: validators.maxWorkers(false), + POOL_WORK_LIMIT: validators.workLimit(false), + POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false), + POOL_CREATE_TIMEOUT: validators.createTimeout(false), + POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false), + POOL_IDLE_TIMEOUT: validators.idleTimeout(false), + POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false), + POOL_REAPER_INTERVAL: validators.reaperInterval(false), + POOL_BENCHMARKING: validators.poolBenchmarking(false), // logging - LOGGING_LEVEL: config.logLevel(false), - LOGGING_FILE: config.logFile(false), - LOGGING_DEST: config.logDest(false), - LOGGING_TO_CONSOLE: config.logToConsole(false), - LOGGING_TO_FILE: config.logToFile(false), + LOGGING_LEVEL: validators.logLevel(false), + LOGGING_FILE: validators.logFile(false), + LOGGING_DEST: validators.logDest(false), + LOGGING_TO_CONSOLE: validators.logToConsole(false), + LOGGING_TO_FILE: validators.logToFile(false), // ui - UI_ENABLE: config.enableUi(false), - UI_ROUTE: config.uiRoute(false), + UI_ENABLE: validators.enableUi(false), + UI_ROUTE: validators.uiRoute(false), // other - OTHER_NODE_ENV: config.nodeEnv(false), - OTHER_LISTEN_TO_PROCESS_EXITS: config.listenToProcessExits(false), - OTHER_NO_LOGO: config.noLogo(false), - OTHER_HARD_RESET_PAGE: config.hardResetPage(false), - OTHER_BROWSER_SHELL_MODE: config.browserShellMode(false), + OTHER_NODE_ENV: validators.nodeEnv(false), + OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false), + OTHER_NO_LOGO: validators.noLogo(false), + OTHER_HARD_RESET_PAGE: validators.hardResetPage(false), + OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false), + OTHER_VALIDATION: validators.validation(false), // debugger - DEBUG_ENABLE: config.enableDebug(false), - DEBUG_HEADLESS: config.headless(false), - DEBUG_DEVTOOLS: config.devtools(false), - DEBUG_LISTEN_TO_CONSOLE: config.listenToConsole(false), - DEBUG_DUMPIO: config.dumpio(false), - DEBUG_SLOW_MO: config.slowMo(false), - DEBUG_DEBUGGING_PORT: config.debuggingPort(false) + DEBUG_ENABLE: validators.enableDebug(false), + DEBUG_HEADLESS: validators.headless(false), + DEBUG_DEVTOOLS: validators.devtools(false), + DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false), + DEBUG_DUMPIO: validators.dumpio(false), + DEBUG_SLOW_MO: validators.slowMo(false), + DEBUG_DEBUGGING_PORT: validators.debuggingPort(false) }); /** @@ -2709,23 +2723,6 @@ export function looseValidate(configOptions) { return LooseConfigSchema.partial().parse(configOptions); } -/** - * Validates a provided option using the specific validator from the config - * object. - * - * @function validateOption - * - * @param {string} name - The name of an option to validate. - * @param {any} option - The option to validate. - * @param {boolean} strictCheck - Determines if stricter validation should - * be applied. - * - * @returns {any} The parsed and validated option value. - */ -export function validateOption(name, option, strictCheck) { - return config[name](strictCheck).parse(option); -} - /** * Custom error mapping function for Zod schema validation. * @@ -2813,11 +2810,11 @@ function _customErrorMap(issue, context) { } export default { + validators, StrictConfigSchema, LooseConfigSchema, EnvSchema, envs, strictValidate, - looseValidate, - validateOption + looseValidate }; From a38fabd3dc9d4bc9538420e1a4ee31880a1cc218 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:30:19 +0100 Subject: [PATCH 09/19] Added two functions for validating data and some corrections. --- lib/config.js | 122 +++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 107 insertions(+), 15 deletions(-) diff --git a/lib/config.js b/lib/config.js index 198645d0..4014901a 100644 --- a/lib/config.js +++ b/lib/config.js @@ -25,9 +25,17 @@ import { join } from 'path'; import { log, logWithStack, logZodIssues } from './logger.js'; import { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js'; -import { envs, looseValidate, strictValidate } from './validation.js'; +import { + envs, + looseValidate, + strictValidate, + validators +} from './validation.js'; + import { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js'; +import ExportError from './errors/ExportError.js'; + // Sets the global options with initial values from the default config const globalOptions = _initGlobalOptions(defaultConfig); @@ -85,36 +93,47 @@ export function setGlobalOptions(customOptions = {}, cliArgs = []) { let cliOptions = {}; // Only for the CLI usage - if (cliArgs.length) { + if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) { try { // Validate options from the custom JSON loaded via the `loadConfig` - configOptions = strictValidate(_loadConfigFile(cliArgs)); + configOptions = strictValidate( + _loadConfigFile(cliArgs, globalOptions.customLogic) + ); } catch (error) { logZodIssues( 1, error.issues, - '[config] Custom JSON options validation error' + '[validation] Custom options from the `loadConfig` option validation error' ); } - } - // Apply custom options if there are any - if (customOptions && Object.keys(customOptions).length !== 0) { try { - // Validate custom options provided by the user - customOptions = strictValidate(customOptions); + // Validate options from the CLI + cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs)); } catch (error) { - logZodIssues(1, error.issues, '[config] Custom options validation error'); + logZodIssues( + 1, + error.issues, + '[validation] CLI options validation error' + ); } } - // Only for the CLI usage - if (cliArgs.length) { + // Apply custom options if there are any + if ( + customOptions && + isObject(customOptions) && + Object.keys(customOptions).length + ) { try { - // Validate options from the CLI - cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs)); + // Validate custom options provided by the user + customOptions = strictValidate(customOptions); } catch (error) { - logZodIssues(1, error.issues, '[config] CLI options validation error'); + logZodIssues( + 1, + error.issues, + '[validation] Custom options validation error' + ); } } @@ -241,6 +260,77 @@ export function mapToNewOptions(oldOptions) { return newOptions; } +/** + * Validates a specified option using the corresponding validator from the + * configuration object. Returns the original option if the validation + * is disabled globally. + * + * @function validateOption + * + * @param {string} name - The name of the option to validate. + * @param {any} configOption - The value of the option to validate. + * @param {boolean} [strictCheck=true] - Determines if stricter validation + * should be applied. The default value is `true`. + * + * @returns {any} The parsed and validated value of the option. + */ +export function validateOption(name, configOption, strictCheck = true) { + // Return the original option if the validation is disabled + if (!getOptions().other.validation) { + return configOption; + } + + try { + // Return validated option + return validators[name](strictCheck).parse(configOption); + } catch (error) { + // Log Zod issues + logZodIssues( + 1, + error.issues, + `[validation] The ${name} option validation error` + ); + + // Throw validation error + throw new ExportError( + `[validation] The ${name} option validation error`, + 400 + ); + } +} + +/** + * Validates the provided configuration options for the exporting process. + * Returns the original option if the validation is disabled globally. + * + * @function validateOptions + * + * @param {Object} configOptions - The configuration options to be validated. + * @param {boolean} [strictCheck=true] - Determines if stricter validation + * should be applied. The default value is `true`. + * + * @returns {Object} The parsed and validated configuration options object. + */ +export function validateOptions(configOptions, strictCheck = true) { + // Return the original config if the validation is disabled + if (!getOptions().other.validation) { + return configOptions; + } + + try { + // Return validated options + return strictCheck + ? strictValidate(configOptions) + : looseValidate(configOptions); + } catch (error) { + // Log Zod issues + logZodIssues(1, error.issues, '[validation] Options validation error'); + + // Throw validation error + throw new ExportError('[validation] Options validation error', 400); + } +} + /** * Validates, parses, and checks if the provided config is allowed set * of options. @@ -676,6 +766,8 @@ export default { updateOptions, mergeOptions, mapToNewOptions, + validateOption, + validateOptions, isAllowedConfig, printLicense, printUsage, From 579f9a6e78ae46c84b25c254fdd814e2cf517907 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:31:04 +0100 Subject: [PATCH 10/19] Secured incoming data with the validation logic. --- lib/chart.js | 72 ++++++++++++----------- lib/index.js | 52 ++++++++++------- lib/prompt.js | 5 +- lib/server/middlewares/validation.js | 87 ++++++++++++---------------- lib/server/routes/versionChange.js | 13 +++++ lib/server/server.js | 22 ++++--- 6 files changed, 138 insertions(+), 113 deletions(-) diff --git a/lib/chart.js b/lib/chart.js index d4ad83ba..c1281d50 100644 --- a/lib/chart.js +++ b/lib/chart.js @@ -21,8 +21,14 @@ See LICENSE file in root for details. import { readFileSync, writeFileSync } from 'fs'; -import { getOptions, isAllowedConfig, mergeOptions } from './config.js'; -import { log, logWithStack, logZodIssues } from './logger.js'; +import { + getOptions, + isAllowedConfig, + mergeOptions, + validateOption, + validateOptions +} from './config.js'; +import { log, logWithStack } from './logger.js'; import { getPoolStats, killPool, postWork } from './pool.js'; import { sanitize } from './sanitize.js'; import { @@ -36,7 +42,6 @@ import { roundNumber, wrapAround } from './utils.js'; -import { strictValidate, validateOption } from './validation.js'; import ExportError from './errors/ExportError.js'; @@ -65,6 +70,9 @@ let allowCodeExecution = false; export async function singleExport(options) { // Check if the export makes sense if (options && options.export) { + // Validate single export options + options = validateOptions(options); + // Perform an export await startExport( { export: options.export, customLogic: options.customLogic }, @@ -134,6 +142,9 @@ export async function singleExport(options) { export async function batchExport(options) { // Check if the export makes sense if (options && options.export && options.export.batch) { + // Validate batch export options + options = validateOptions(options); + // An array for collecting batch exports const batchFunctions = []; @@ -292,29 +303,11 @@ export async function startExport(exportingOptions, endCallback) { // Check the file's extension if (exportOptions.infile.endsWith('.svg')) { - try { - // Set to the `svg` option - exportOptions.svg = validateOption('svg', fileContent, false); - } catch (error) { - logZodIssues( - 1, - error.issues, - '[config] The `svg` option validation error' - ); - throw error; - } + // Set to the `svg` option + exportOptions.svg = validateOption('svg', fileContent); } else if (exportOptions.infile.endsWith('.json')) { - try { - // Set to the `instr` option - exportOptions.instr = validateOption('instr', fileContent, false); - } catch (error) { - logZodIssues( - 1, - error.issues, - '[config] The `instr` option validation error' - ); - throw error; - } + // Set to the `instr` option + exportOptions.instr = validateOption('instr', fileContent); } else { throw new ExportError( '[chart] Incorrect value of the `infile` option.', @@ -531,14 +524,6 @@ async function _prepareExport(options) { ..._findChartSize(exportOptions) }; - // The last strict validation of options right before exporting process - try { - // Validate final options - options = strictValidate(options); - } catch (error) { - logZodIssues(1, error.issues, '[config] Final options validation error'); - } - // Post the work to the pool return postWork(options); } @@ -679,6 +664,12 @@ function _handleCustomLogic(customLogicOptions, allowCodeExecution) { customLogicOptions.customCode, customLogicOptions.allowFileResources ); + + // Validate the option + customLogicOptions.customCode = validateOption( + 'customCode', + customLogicOptions.customCode + ); } catch (error) { logWithStack(2, error, '[chart] The `customCode` cannot be loaded.'); @@ -694,6 +685,12 @@ function _handleCustomLogic(customLogicOptions, allowCodeExecution) { customLogicOptions.allowFileResources, true ); + + // Validate the option + customLogicOptions.callback = validateOption( + 'callback', + customLogicOptions.callback + ); } catch (error) { logWithStack(2, error, '[chart] The `callback` cannot be loaded.'); @@ -808,6 +805,9 @@ function _handleResources( } } + // Validate option + handledResources = validateOption('resources', handledResources); + // Return resources return handledResources; } @@ -860,6 +860,12 @@ function _handleGlobalAndTheme( allowCodeExecution ); } + + // Validate the option + exportOptions[optionsName] = validateOption( + optionsName, + exportOptions[optionsName] + ); } } catch (error) { logWithStack( diff --git a/lib/index.js b/lib/index.js index 2d90259d..3edeb8f4 100644 --- a/lib/index.js +++ b/lib/index.js @@ -32,7 +32,9 @@ import { getOptions, updateOptions, setGlobalOptions, - mapToNewOptions + mapToNewOptions, + validateOption, + validateOptions } from './config.js'; import { log, @@ -65,8 +67,8 @@ import server from './server/server.js'; * is an empty object. */ export async function initExport(initOptions = {}) { - // Init and update the instance options object - const options = updateOptions(initOptions, true); + // Init, validate and update the instance options object + const options = updateOptions(validateOptions(initOptions), true); // Set the `allowCodeExecution` per export module scope setAllowCodeExecution(options.customLogic.allowCodeExecution); @@ -135,6 +137,10 @@ export default { setGlobalOptions, mapToNewOptions, + // Validation + validateOption, + validateOptions, + // Exporting initExport, singleExport, @@ -151,35 +157,41 @@ export default { logZodIssues, setLogLevel: function (level) { // Update the instance options object - const options = updateOptions({ - logging: { - level - } - }); + const options = updateOptions( + validateOptions({ + logging: { + level + } + }) + ); // Call the function setLogLevel(options.logging.level); }, enableConsoleLogging: function (toConsole) { // Update the instance options object - const options = updateOptions({ - logging: { - toConsole - } - }); + const options = updateOptions( + validateOptions({ + logging: { + toConsole + } + }) + ); // Call the function enableConsoleLogging(options.logging.toConsole); }, enableFileLogging: function (dest, file, toFile) { // Update the instance options object - const options = updateOptions({ - logging: { - dest, - file, - toFile - } - }); + const options = updateOptions( + validateOptions({ + logging: { + dest, + file, + toFile + } + }) + ); // Call the function enableFileLogging( diff --git a/lib/prompt.js b/lib/prompt.js index d4ac3f6b..9f073129 100644 --- a/lib/prompt.js +++ b/lib/prompt.js @@ -23,7 +23,7 @@ import { writeFile } from 'fs/promises'; import prompts from 'prompts'; -import { isAllowedConfig } from './config.js'; +import { isAllowedConfig, validateOptions } from './config.js'; import { log, logWithStack } from './logger.js'; import { getAbsolutePath } from './utils.js'; @@ -166,6 +166,9 @@ export async function manualConfig(configFileName, allowCodeExecution) { // If all questions have been answered, save the updated config if (++questionsCounter === allQuestions.length) { try { + // Validate the prompt result + configFile = validateOptions(configFile); + // Save the prompt result await writeFile( getAbsolutePath(configFileName), diff --git a/lib/server/middlewares/validation.js b/lib/server/middlewares/validation.js index d39224ee..4af2496e 100644 --- a/lib/server/middlewares/validation.js +++ b/lib/server/middlewares/validation.js @@ -26,7 +26,7 @@ See LICENSE file in root for details. import { v4 as uuid } from 'uuid'; import { getAllowCodeExecution } from '../../chart.js'; -import { isAllowedConfig } from '../../config.js'; +import { isAllowedConfig, validateOptions } from '../../config.js'; import { log, logZodIssues } from '../../logger.js'; import { fixConstr, @@ -152,55 +152,42 @@ function requestBodyMiddleware(request, response, next) { ); } - try { - // Validate options from the body and store parsed structure in the request - request.validatedOptions = looseValidate({ - // Set the created ID as a `_requestId` property in the validated options - _requestId: requestId, - export: { - instr, - svg: body.svg, - outfile: - body.outfile || - `${request.params.filename || 'chart'}.${fixType(body.type)}`, - type: fixType(body.type, body.outfile), - constr: fixConstr(body.constr), - b64: body.b64, - noDownload: body.noDownload, - height: body.height, - width: body.width, - scale: body.scale, - globalOptions: isAllowedConfig( - body.globalOptions, - true, - allowCodeExecution - ), - themeOptions: isAllowedConfig( - body.themeOptions, - true, - allowCodeExecution - ) - }, - customLogic: { - allowCodeExecution, - allowFileResources: false, - customCode: body.customCode, - callback: body.callback, - resources: isAllowedConfig(body.resources, true, allowCodeExecution) - } - }); - } catch (error) { - logZodIssues( - 1, - error.issues, - '[config] Request options validation error' - ); - - throw new ExportError( - 'The provided options are not correct. Please check if your data is of the correct types.', - 400 - ); - } + // Validate the request options and store parsed structure in the request + request.validatedOptions = validateOptions({ + // Set the created ID as a `requestId` property in the options + requestId, + export: { + instr, + svg: body.svg, + outfile: + body.outfile || + `${request.params.filename || 'chart'}.${body.type || 'png'}`, + type: body.type, + constr: body.constr, + b64: body.b64, + noDownload: body.noDownload, + height: body.height, + width: body.width, + scale: body.scale, + globalOptions: isAllowedConfig( + body.globalOptions, + true, + allowCodeExecution + ), + themeOptions: isAllowedConfig( + body.themeOptions, + true, + allowCodeExecution + ) + }, + customLogic: { + allowCodeExecution, + allowFileResources: false, + customCode: body.customCode, + callback: body.callback, + resources: isAllowedConfig(body.resources, true, allowCodeExecution) + } + }); // Call the next middleware return next(); diff --git a/lib/server/routes/versionChange.js b/lib/server/routes/versionChange.js index ad49c2c0..f8512576 100644 --- a/lib/server/routes/versionChange.js +++ b/lib/server/routes/versionChange.js @@ -18,6 +18,7 @@ See LICENSE file in root for details. */ import { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js'; +import { validateOption } from '../../config.js'; import { log } from '../../logger.js'; import { envs } from '../../validation.js'; @@ -63,6 +64,18 @@ export default function versionChangeRoutes(app) { // Compare versions let newVersion = request.params.newVersion; + + // Validate the version + try { + newVersion = validateOption('version', request.params.newVersion); + } catch (error) { + throw new ExportError( + `[version] Version is incorrect: ${error.message}`, + 400 + ).setError(error); + } + + // When a correct value found if (newVersion) { try { // Update version diff --git a/lib/server/server.js b/lib/server/server.js index ba744174..2e8bf81c 100644 --- a/lib/server/server.js +++ b/lib/server/server.js @@ -30,7 +30,7 @@ import http from 'http'; import https from 'https'; import multer from 'multer'; -import { updateOptions } from '../config.js'; +import { updateOptions, validateOptions } from '../config.js'; import { log, logWithStack } from '../logger.js'; import { __dirname, getAbsolutePath } from '../utils.js'; @@ -74,9 +74,11 @@ const app = express(); export async function startServer(serverOptions) { try { // Update the instance options object - const options = updateOptions({ - server: serverOptions - }); + const options = updateOptions( + validateOptions({ + server: serverOptions + }) + ); // Use validated options serverOptions = options.server; @@ -293,11 +295,13 @@ export function getApp() { */ export function enableRateLimiting(rateLimitingOptions) { // Update the instance options object - const options = updateOptions({ - server: { - rateLimiting: rateLimitingOptions - } - }); + const options = updateOptions( + validateOptions({ + server: { + rateLimiting: rateLimitingOptions + } + }) + ); // Set the rate limiting options rateLimitingMiddleware(app, options.server.rateLimitingOptions); From 45cac8486e5922c21a138351a8bc9738f234128d Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:31:18 +0100 Subject: [PATCH 11/19] The logZodIssues function small modifications. --- lib/logger.js | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/lib/logger.js b/lib/logger.js index 0bc5e748..2833aa2d 100644 --- a/lib/logger.js +++ b/lib/logger.js @@ -160,23 +160,23 @@ export function logWithStack(newLevel, error, customMessage) { } /** - * Logs an error message about Zod issues with the validation. Optionally, - * a custom message can be provided. + * Logs an error message related to Zod validation issues. Optionally, a custom + * message can be provided. * * @function logZodIssues * * @param {number} newLevel - The log level. - * @param {Error[]} issues - The array of Zod issues. - * @param {string} customMessage - An optional custom message to be logged - * along with the error. + * @param {Error[]} issues - An array of Zod validation issues. + * @param {string} customMessage - An optional custom message to be included + * in the log alongside the error. */ -export function logZodIssues(newLevel, issues = [], customMessage) { +export function logZodIssues(newLevel, issues, customMessage) { logWithStack( newLevel, null, [ - `${customMessage} - the following Zod issues occured:`, - ...issues.map((issue) => `- ${issue.message}`) + `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`, + ...(issues || []).map((issue) => `- ${issue.message}`) ].join('\n') ); } From ac9cfb8b989ab9784012d7825b5b4fa88e1b5cdc Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:31:31 +0100 Subject: [PATCH 12/19] Added tests for the validation and requestId parameters. --- tests/unit/validation/cli.test.js | 26 +++++++------------- tests/unit/validation/config.test.js | 26 +++++++------------- tests/unit/validation/envs.test.js | 3 +++ tests/unit/validation/shared.js | 36 +++++++++++----------------- 4 files changed, 33 insertions(+), 58 deletions(-) diff --git a/tests/unit/validation/cli.test.js b/tests/unit/validation/cli.test.js index e69a1a03..ad92238c 100644 --- a/tests/unit/validation/cli.test.js +++ b/tests/unit/validation/cli.test.js @@ -21,6 +21,9 @@ describe('CLI options should be correctly parsed and validated', () => { // Return config tests with a specific schema and strictCheck flag injected const tests = configTests(LooseConfigSchema.partial(), false); + // requestId + tests.requestId('requestId'); + // puppeteer tests.puppeteer('puppeteer', { args: [ @@ -253,7 +256,8 @@ describe('CLI options should be correctly parsed and validated', () => { listenToProcessExits: true, noLogo: false, hardResetPage: false, - browserShellMode: true + browserShellMode: true, + validation: true }); // debug @@ -266,13 +270,6 @@ describe('CLI options should be correctly parsed and validated', () => { slowMo: 0, debuggingPort: 9222 }); - - //// - // // payload - // tests.payload('payload', { - // requestId: 'd4faa416-0e85-433a-9f84-e735567d8fa5' - // }); - //// }); describe('Puppeteer configuration options should be correctly parsed and validated', () => { @@ -632,6 +629,9 @@ describe('Other configuration options should be correctly parsed and validated', // other.browserShellMode tests.otherBrowserShellMode('browserShellMode'); + + // other.validation + tests.otherValidation('validation'); }); describe('Debug configuration options should be correctly parsed and validated', () => { @@ -659,13 +659,3 @@ describe('Debug configuration options should be correctly parsed and validated', // debug.debuggingPort tests.debugDebuggingPort('debuggingPort'); }); - -//// -// describe('Payload configuration options should be correctly parsed and validated', () => { -// // Return config tests with a specific schema and strictCheck flag injected -// const tests = configTests(LooseConfigSchema.shape.payload, false); - -// // payload.requestId -// tests.payloadRequestId('requestId'); -// }); -//// diff --git a/tests/unit/validation/config.test.js b/tests/unit/validation/config.test.js index 7f0a6531..3d360d90 100644 --- a/tests/unit/validation/config.test.js +++ b/tests/unit/validation/config.test.js @@ -21,6 +21,9 @@ describe('Configuration options should be correctly parsed and validated', () => // Return config tests with a specific schema and strictCheck flag injected const tests = configTests(StrictConfigSchema.partial(), true); + // requestId + tests.requestId('requestId'); + // puppeteer tests.puppeteer('puppeteer', { args: [ @@ -253,7 +256,8 @@ describe('Configuration options should be correctly parsed and validated', () => listenToProcessExits: true, noLogo: false, hardResetPage: false, - browserShellMode: true + browserShellMode: true, + validation: true }); // debug @@ -266,13 +270,6 @@ describe('Configuration options should be correctly parsed and validated', () => slowMo: 0, debuggingPort: 9222 }); - - //// - // // payload - // tests.payload('payload', { - // requestId: 'd4faa416-0e85-433a-9f84-e735567d8fa5' - // }); - //// }); describe('Puppeteer configuration options should be correctly parsed and validated', () => { @@ -643,6 +640,9 @@ describe('Other configuration options should be correctly parsed and validated', // other.browserShellMode tests.otherBrowserShellMode('browserShellMode'); + + // other.validation + tests.otherValidation('validation'); }); describe('Debug configuration options should be correctly parsed and validated', () => { @@ -670,13 +670,3 @@ describe('Debug configuration options should be correctly parsed and validated', // debug.debuggingPort tests.debugDebuggingPort('debuggingPort'); }); - -//// -// describe('Payload configuration options should be correctly parsed and validated', () => { -// // Return config tests with a specific schema and strictCheck flag injected -// const tests = configTests(StrictConfigSchema.shape.payload, true); - -// // payload.requestId -// tests.payloadRequestId('requestId'); -// }); -//// diff --git a/tests/unit/validation/envs.test.js b/tests/unit/validation/envs.test.js index 1be06f7c..7e5cd8dc 100644 --- a/tests/unit/validation/envs.test.js +++ b/tests/unit/validation/envs.test.js @@ -315,6 +315,9 @@ describe('OTHER environment variables should be correctly parsed and validated', // OTHER_BROWSER_SHELL_MODE tests.otherBrowserShellMode('OTHER_BROWSER_SHELL_MODE'); + + // OTHER_VALIDATION + tests.otherValidation('OTHER_VALIDATION'); }); describe('DEBUG environment variables should be correctly parsed and validated', () => { diff --git a/tests/unit/validation/shared.js b/tests/unit/validation/shared.js index 593d5b63..4edc16ab 100644 --- a/tests/unit/validation/shared.js +++ b/tests/unit/validation/shared.js @@ -214,6 +214,13 @@ export function configTests(schema, strictCheck) { expect(schema.parse(obj)[property]).toBe(false); }); + it('should accept a stringified 0 and 1 values and transform them to a boolean', () => { + const obj = { [property]: '1' }; + expect(schema.parse(obj)[property]).toBe(true); + obj[property] = '0'; + expect(schema.parse(obj)[property]).toBe(false); + }); + it('should accept null', () => { acceptNull(property); }); @@ -234,6 +241,7 @@ export function configTests(schema, strictCheck) { validatePropOfSchema(schema, property, [ 'emptyString', 'stringBoolean', + 'stringNumber', 'stringUndefined', 'stringNull', 'boolean', @@ -1057,20 +1065,6 @@ export function configTests(schema, strictCheck) { expect(schema.parse(obj)[property]).toBe('{ a: "1", b: { c: 3 } }'); }); - it('should accept a string value that starts with the { - const obj = { - [property]: "..." - }; - expect(schema.parse(obj)[property]).toBe( - "..." - ); - obj[property] = - '...'; - expect(schema.parse(obj)[property]).toBe( - '...' - ); - }); - it('should not accept any array values', () => { const obj = { [property]: [] }; expect(() => schema.parse(obj)).toThrow(); @@ -2241,6 +2235,9 @@ export function configTests(schema, strictCheck) { // The options config validation tests return { + requestId: (property) => { + describe(property, () => validationTests.requestId(property)); + }, puppeteer: (property, value) => { describe(property, () => validationTests.configObject(property, value)); }, @@ -2531,6 +2528,9 @@ export function configTests(schema, strictCheck) { otherBrowserShellMode: (property) => { describe(property, () => validationTests.boolean(property)); }, + otherValidation: (property) => { + describe(property, () => validationTests.boolean(property)); + }, debug: (property, value) => { describe(property, () => validationTests.configObject(property, value)); }, @@ -2555,13 +2555,5 @@ export function configTests(schema, strictCheck) { debugDebuggingPort: (property) => { describe(property, () => validationTests.nonNegativeNum(property)); } - //// - // payload: (property, value) => { - // describe(property, () => validationTests.configObject(property, value)); - // }, - // payloadRequestId: (property) => { - // describe(property, () => validationTests.requestId(property)); - // } - //// }; } From b564f2cc6f0a0cef44c44523fa8eeb2facce32ae Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:31:39 +0100 Subject: [PATCH 13/19] Updated README with the new info about validation option and new validating API functions. --- README.md | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 06375eec..319fc06f 100644 --- a/README.md +++ b/README.md @@ -270,7 +270,8 @@ _Available default JSON config:_ "listenToProcessExits": true, "noLogo": false, "hardResetPage": false, - "browserShellMode": true + "browserShellMode": true, + "validation": true }, "debug": { "enable": false, @@ -406,6 +407,7 @@ _Available environment variables:_ - `OTHER_NO_LOGO`: Skip printing the logo on a startup. Will be replaced by a simple text (defaults to `false`). - `OTHER_HARD_RESET_PAGE`: Determines whether the page's content should be reset from scratch, including Highcharts scripts (defaults to `false`). - `OTHER_BROWSER_SHELL_MODE`: Decides whether to enable older but much more performant _shell_ mode for the browser (defaults to `true`). +- `OTHER_VALIDATION`: Decides whether or not to enable validation of options types (defaults to `true`). ### Debugging Config @@ -537,6 +539,7 @@ _Available CLI arguments:_ - `--noLogo`: Skip printing the logo on a startup. Will be replaced by a simple text (defaults to `false`). - `--hardResetPage`: Determines whether the page's content should be reset from scratch, including Highcharts scripts (defaults to `false`). - `--browserShellMode`: Decides whether to enable older but much more performant _shell_ mode for the browser (defaults to `true`). +- `--validation`: Decides whether or not to enable validation of options types (defaults to `true`). ### Debugging Config @@ -776,6 +779,21 @@ This package supports both CommonJS and ES modules. - `@returns {Object}` A new object containing options structured according to the mapping defined in `nestedProps` or an empty object if the provided `oldOptions` is not a correct object. +- `function validateOption(name, configOption, strictCheck = true)`: Validates a specified option using the corresponding validator from the configuration object. Returns the original option if the validation is disabled globally. + + - `@param {string} name` - The name of the option to validate. + - `@param {any} configOption` - The value of the option to validate. + - `@param {boolean} [strictCheck=true]` - Determines if stricter validation should be applied. The default value is `true`. + + - `@returns {any}` The parsed and validated value of the option. + +- `function validateOptions(configOptions, strictCheck = true)`: Validates the provided configuration options for the exporting process. Returns the original option if the validation is disabled globally. + + - `@param {Object} configOptions` - The configuration options to be validated. + - `@param {boolean} [strictCheck=true]` - Determines if stricter validation should be applied. The default value is `true`. + + - `@returns {Object}` The parsed and validated configuration options object. + - `async function initExport(initOptions = {})`: Initializes the export process. Tasks such as configuring logging, checking the cache and sources, and initializing the resource pool occur during this stage. This function must be called before attempting to export charts or set up a server. @@ -831,11 +849,11 @@ This package supports both CommonJS and ES modules. - `@returns {void}` Exits the function execution if attempting to log at a level higher than allowed. -- `function logZodIssues(newLevel, issues = [], customMessage)`: Logs an error message about Zod issues with the validation. Optionally, a custom message can be provided. +- `function logZodIssues(newLevel, issues, customMessage)`: Logs an error message related to Zod validation issues. Optionally, a custom message can be provided. - `@param {number} newLevel` - The log level. - - `@param {Error[]} issues` - The array of Zod issues. - - `@param {string} customMessage` - An optional custom message to be logged along with the error. + - `@param {Error[]} issues` - An array of Zod validation issues. + - `@param {string} customMessage` - An optional custom message to be included in the log alongside the error. - `function setLogLevel(level)`: Sets the log level to the specified value. Log levels are (`0` = no logging, `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark). From 67e8093c35b065dc55bb62690ac0b35303e033fd Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:32:09 +0100 Subject: [PATCH 14/19] Built scripts. --- dist/index.cjs | 4 ++-- dist/index.esm.js | 2 +- dist/index.esm.js.map | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dist/index.cjs b/dist/index.cjs index d82b30a2..3bc873ff 100644 --- a/dist/index.cjs +++ b/dist/index.cjs @@ -1,2 +1,2 @@ -"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),promises=require("fs/promises"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},n=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":n.includes(o)&&e!==o&&(e=o)}return o[e]||n.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?e:path.join(__dirname$1,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:n,level:r}=logging;if(5!==t&&(0===t||t>r||r>n.length))return;const i=`${getNewDate()} [${n[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const n=o||t&&t.message||"",{level:r,levelsDesc:i}=logging;if(0===e||e>r||r>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t&&t.stack,l=[n];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t=[],o){logWithStack(e,null,[`${o} - the following Zod issues occured:`,...t.map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:n,toConsole:r,toFile:i}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(r),enableFileLogging(o,n,i)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((n=>{const r=e[n];void 0===r.value?_createNestedProps(r,t,`${o}.${n}`):(t[r.cliName||n]=`${o}.${n}`.substring(1),void 0!==r.legacyName&&(t[r.legacyName]=`${o}.${n}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const n=e[o];void 0===n.types?_createAbsoluteProps(n,t):n.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","false","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const n=zod.z.string().trim().array(),r=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?n.transform(i):zod.z.union([r,n]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},config={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),n=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json'"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,n]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json "}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with '.log'"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:config.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:config.version(e),cdnUrl:config.cdnUrl(e),forceFetch:config.forceFetch(e),cachePath:config.cachePath(e),coreScripts:config.coreScripts(e),moduleScripts:config.moduleScripts(e),indicatorScripts:config.indicatorScripts(e),customScripts:config.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:config.infile(e),instr:config.instr(),options:config.options(),svg:config.svg(),outfile:config.outfile(e),type:config.type(e),constr:config.constr(e),b64:config.b64(e),noDownload:config.noDownload(e),defaultHeight:config.defaultHeight(e),defaultWidth:config.defaultWidth(e),defaultScale:config.defaultScale(e),height:config.height(e),width:config.width(e),scale:config.scale(e),globalOptions:config.globalOptions(),themeOptions:config.themeOptions(),batch:config.batch(!1),rasterizationTimeout:config.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:config.allowCodeExecution(e),allowFileResources:config.allowFileResources(e),customCode:config.customCode(!1),callback:config.callback(!1),resources:config.resources(e),loadConfig:config.loadConfig(!1),createConfig:config.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:config.proxyHost(!1),port:config.proxyPort(e),timeout:config.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:config.enableRateLimiting(e),maxRequests:config.maxRequests(e),window:config.window(e),delay:config.delay(e),trustProxy:config.trustProxy(e),skipKey:config.skipKey(!1),skipToken:config.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:config.enableSsl(e),force:config.sslForce(e),port:config.sslPort(e),certPath:config.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:config.enableServer(e).optional(),host:config.host(e).optional(),port:config.port(e).optional(),benchmarking:config.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:config.minWorkers(e),maxWorkers:config.maxWorkers(e),workLimit:config.workLimit(e),acquireTimeout:config.acquireTimeout(e),createTimeout:config.createTimeout(e),destroyTimeout:config.destroyTimeout(e),idleTimeout:config.idleTimeout(e),createRetryInterval:config.createRetryInterval(e),reaperInterval:config.reaperInterval(e),benchmarking:config.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:config.logLevel(e),file:config.logFile(e),dest:config.logDest(e),toConsole:config.logToConsole(e),toFile:config.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:config.enableUi(e),route:config.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:config.nodeEnv(e),listenToProcessExits:config.listenToProcessExits(e),noLogo:config.noLogo(e),hardResetPage:config.hardResetPage(e),browserShellMode:config.browserShellMode(e)}).partial(),DebugSchema=e=>zod.z.object({enable:config.enableDebug(e),headless:config.headless(e),devtools:config.devtools(e),listenToConsole:config.listenToConsole(e),dumpio:config.dumpio(e),slowMo:config.slowMo(e),debuggingPort:config.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:config.args(!1),HIGHCHARTS_VERSION:config.version(!1),HIGHCHARTS_CDN_URL:config.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:config.forceFetch(!1),HIGHCHARTS_CACHE_PATH:config.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:config.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:config.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:config.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:config.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:config.customScripts(!1),EXPORT_INFILE:config.infile(!1),EXPORT_INSTR:config.instr(),EXPORT_OPTIONS:config.options(),EXPORT_SVG:config.svg(),EXPORT_BATCH:config.batch(!1),EXPORT_OUTFILE:config.outfile(!1),EXPORT_TYPE:config.type(!1),EXPORT_CONSTR:config.constr(!1),EXPORT_B64:config.b64(!1),EXPORT_NO_DOWNLOAD:config.noDownload(!1),EXPORT_HEIGHT:config.height(!1),EXPORT_WIDTH:config.width(!1),EXPORT_SCALE:config.scale(!1),EXPORT_DEFAULT_HEIGHT:config.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:config.defaultWidth(!1),EXPORT_DEFAULT_SCALE:config.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:config.globalOptions(),EXPORT_THEME_OPTIONS:config.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:config.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:config.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:config.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:config.customCode(!1),CUSTOM_LOGIC_CALLBACK:config.callback(!1),CUSTOM_LOGIC_RESOURCES:config.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:config.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:config.createConfig(!1),SERVER_ENABLE:config.enableServer(!1),SERVER_HOST:config.host(!1),SERVER_PORT:config.port(!1),SERVER_UPLOAD_LIMIT:config.uploadLimit(!1),SERVER_BENCHMARKING:config.serverBenchmarking(!1),SERVER_PROXY_HOST:config.proxyHost(!1),SERVER_PROXY_PORT:config.proxyPort(!1),SERVER_PROXY_TIMEOUT:config.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:config.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:config.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:config.window(!1),SERVER_RATE_LIMITING_DELAY:config.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:config.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:config.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:config.skipToken(!1),SERVER_SSL_ENABLE:config.enableSsl(!1),SERVER_SSL_FORCE:config.sslForce(!1),SERVER_SSL_PORT:config.sslPort(!1),SERVER_SSL_CERT_PATH:config.sslCertPath(!1),POOL_MIN_WORKERS:config.minWorkers(!1),POOL_MAX_WORKERS:config.maxWorkers(!1),POOL_WORK_LIMIT:config.workLimit(!1),POOL_ACQUIRE_TIMEOUT:config.acquireTimeout(!1),POOL_CREATE_TIMEOUT:config.createTimeout(!1),POOL_DESTROY_TIMEOUT:config.destroyTimeout(!1),POOL_IDLE_TIMEOUT:config.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:config.createRetryInterval(!1),POOL_REAPER_INTERVAL:config.reaperInterval(!1),POOL_BENCHMARKING:config.poolBenchmarking(!1),LOGGING_LEVEL:config.logLevel(!1),LOGGING_FILE:config.logFile(!1),LOGGING_DEST:config.logDest(!1),LOGGING_TO_CONSOLE:config.logToConsole(!1),LOGGING_TO_FILE:config.logToFile(!1),UI_ENABLE:config.enableUi(!1),UI_ROUTE:config.uiRoute(!1),OTHER_NODE_ENV:config.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:config.listenToProcessExits(!1),OTHER_NO_LOGO:config.noLogo(!1),OTHER_HARD_RESET_PAGE:config.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:config.browserShellMode(!1),DEBUG_ENABLE:config.enableDebug(!1),DEBUG_HEADLESS:config.headless(!1),DEBUG_DEVTOOLS:config.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:config.listenToConsole(!1),DEBUG_DUMPIO:config.dumpio(!1),DEBUG_SLOW_MO:config.slowMo(!1),DEBUG_DEBUGGING_PORT:config.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function validateOption(e,t,o){return config[e](o).parse(t)}function _customErrorMap(e,t){const o=e.path.join("."),n=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${n} - No value was provided.`}:{message:`${n} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${n} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${n} - ${t.defaultError}.`}}const globalOptions=_initGlobalOptions(defaultConfig),instanceOptions=deepCopy(globalOptions);function getOptions(e=!0){return e?instanceOptions:globalOptions}function setGlobalOptions(e={},t=[]){let o={},n={};if(t.length)try{o=strictValidate(_loadConfigFile(t))}catch(e){logZodIssues(1,e.issues,"[config] Custom JSON options validation error")}if(e&&0!==Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Custom options validation error")}if(t.length)try{n=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[config] CLI options validation error")}return _updateGlobalOptions(defaultConfig,globalOptions,o,n,e),globalOptions}function updateOptions(e,t=!1){return t&&(Object.keys(instanceOptions).forEach((e=>{delete instanceOptions[e]})),mergeOptions(instanceOptions,deepCopy(globalOptions))),mergeOptions(instanceOptions,e),instanceOptions}function mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,n]of Object.entries(t))e[o]=isObject(n)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],n):void 0!==n?n:e[o]||null;return e}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,n]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,r)=>t[o]=e.length-1===r?n:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,n]of Object.entries(e))if(Object.prototype.hasOwnProperty.call(n,"value")){const e=envs[n.envLink];t[o]=null!=e?e:n.value}else t[o]=_initGlobalOptions(n);return t}function _updateGlobalOptions(e,t,o,n,r){Object.keys(e).forEach((i=>{const s=e[i],a=o&&o[i],l=n&&n[i],c=r&&r[i];if(void 0===s.value)_updateGlobalOptions(s,t[i],a,l,c);else{null!=a&&(t[i]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[i]=e),null!=l&&(t[i]=l),null!=c&&(t[i]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,n)=>{if("string"==typeof n&&(n=n.trim()),"function"==typeof n||"string"==typeof n&&n.startsWith("function")&&n.endsWith("}")){if(t)return o?`"EXP_FUN${(n+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(n+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return n})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e,t){const o=e.findIndex((e=>"loadConfig"===e.replace(/-/g,"")));return o>-1&&e[o+1]&&t.allowFileResources,{}}function _pairArgumentValue(e,t){const o={};for(let n=0;n{if(i.length-1===s){const i=t[++n];i||log(2,`[config] Missing value for the CLI '--${r}' argument. Using the default value.`),e[o]=i||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,n)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||n("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{n(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const n=getCachePath(),r=path.join(n,"manifest.json"),i=path.join(n,"sources.js");if(!fs.existsSync(n)&&fs.mkdirSync(n,{recursive:!0}),!fs.existsSync(r)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let n=!1;const s=JSON.parse(fs.readFileSync(r),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),n=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),n=!0):n=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),n?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,n=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const r=await fetch(`${e}.js`,t);if(200===r.statusCode&&"string"==typeof r.text){if(o){o[extractModuleName(e)]=1}return r.text}if(n)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${r.statusCode}).`,404).setError(r);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,n,r){let i;const s=n.host,a=n.port;if(s&&a)try{i=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:n.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,r,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,r))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const n="latest"===e.version?null:`${e.version}`,r=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${n||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>n?`${r}/${n}/${e}`:`${r}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?n?`${r}/maps/${n}/modules/${e}`:`${r}/maps/modules/${e}`:n?`${r}/${n}/modules/${e}`:`${r}/modules/${e}`)),...e.indicatorScripts.map((e=>n?`${r}/stock/${n}/indicators/${e}`:`${r}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:n,merge:r,wrap:i}=Highcharts;Highcharts.setOptionsObj=r(!1,{},o()),window.isRenderComplete=!1,i(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=r(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),i(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=r(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&n(c),Highcharts[e.constr]("container",p,u);const g=o();for(const e in g)"function"!=typeof g[e]&&delete g[e];n(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:n,...r}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...n&&r};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),n&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],n=t.resources;if(n){const r=[];if(n.js&&r.push({content:n.js}),n.files)for(const e of n.files){const t=!e.startsWith("http");r.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of r)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}r.length=0;const i=[];if(n.css){let r=n.css.match(/@import\s*([^;]*);/g);if(r)for(let e of r)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:path.join(__dirname$1,e)}));i.push({content:n.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const n of[...e,...t,...o])n.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const n=[];try{let r=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;r=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);n.push(...await addPageResources(e,o));const i=r?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,n=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:n}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||t.height)),c=Math.abs(Math.ceil(i.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:r?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,n),p}catch(t){return await clearPageResources(e,n),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:n,height:r}=e.getBoundingClientRect();return{x:t,y:o,width:n,height:Math.trunc(r>1?r:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,n){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),n||1500)))])}async function _createPDF(e,t,o,n){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:n||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const n=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),i=await puppeteerExport(t.page,e.export,e.customLogic);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(i):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${r()}ms.`).setError(i);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t);const s=getNewDateTime()-n;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:n,allCreated:r,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${n}.`),log(5,`[pool] The number of all created (used and free) resources: ${r}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:n,type:r}=t.options.export;try{o?fs.writeFileSync(`${n.split(".").shift()||"chart"}.txt`,getBase64(t.result,r)):fs.writeFileSync(n||`chart.${r}`,"svg"!==r?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:n,type:r}=t.options.export;try{o?fs.writeFileSync(`${n.split(".").shift()||"chart"}.txt`,getBase64(t.result,r)):fs.writeFileSync(n,"svg"!==r?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.",400);const o=mergeOptions(deepCopy(getOptions()),{export:e.export,customLogic:e.customLogic}),n=o.export;if(log(4,"[chart] Starting the exporting process."),null!==n.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(n.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(n.infile.endsWith(".svg"))try{n.svg=validateOption("svg",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `svg` option validation error"),e}else{if(!n.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);try{n.instr=validateOption("instr",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `instr` option validation error"),e}}}if(null!==n.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(n.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==n.instr||null!==n.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(n.instr||n.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)};try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Final options validation error")}return postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:n,exporting:r}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||r?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||r?.sourceHeight||n?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||r?.sourceWidth||n?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const n=["js","css","files"];let r=e,i=!1;if(t&&e.endsWith(".json"))try{r=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files;for(const e in r)n.includes(e)?i||(i=!0):delete r[e];return i?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((n=>{try{e[n]&&(t&&"string"==typeof e[n]&&e[n].endsWith(".json")?e[n]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[n]),"utf8"),!0,o):e[n]=isAllowedConfig(e[n],!0,o))}catch(t){logWithStack(2,t,`[chart] The \`${n}\` cannot be loaded.`),e[n]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,n){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,n(e)}function returnErrorMiddleware(e,t,o,n){const{message:r,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:r,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",n={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};n.trustProxy&&e.enable("trust proxy");const r=rateLimit({windowMs:60*n.window*1e3,limit:n.maxRequests,delayMs:n.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==n.skipKey&&null!==n.skipToken&&e.query.key===n.skipKey&&e.query.access_token===n.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(r),log(3,`[rate limiting] Enabled rate limiting with ${n.maxRequests} requests per ${n.window} minute for each IP, trusting proxy: ${n.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,n=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${n}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${n}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const r=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,r);if(null===i&&!t.svg)throw log(2,`[validation] Request [${n}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${n}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${n}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);try{e.validatedOptions=looseValidate({_requestId:n,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${fixType(t.type)}`,type:fixType(t.type,t.outfile),constr:fixConstr(t.constr),b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,r),themeOptions:isAllowedConfig(t.themeOptions,!0,r)},customLogic:{allowCodeExecution:r,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,r)}})}catch(e){throw logZodIssues(1,e.issues,"[config] Request options validation error"),new ExportError("The provided options are not correct. Please check if your data is of the correct types.",400)}return o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let n=!1;e.socket.on("close",(e=>{e&&(n=!0)}));const r=e.validatedOptions,i=r.requestId;log(4,`[export] Request [${i}] - Got an incoming HTTP request.`),await startExport(r,((r,s)=>{if(e.socket.removeAllListeners("close"),n)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(r)throw r;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${i}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:n,noDownload:r,outfile:a}=s.options.export;return n?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),r||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,n=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:n,message:isNaN(n)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${n.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const n=e.get("hc-auth");if(!n||n!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let r=e.params.newVersion;if(!r)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(r)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${r}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,n=multer.memoryStorage(),r=multer({storage:n,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(r.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const n=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(n),n.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,n),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(e,!0);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,setGlobalOptions:setGlobalOptions,mapToNewOptions:mapToNewOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const n=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(n.logging.dest,n.logging.file,n.logging.toFile)}};exports.default=index,exports.initExport=initExport; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/config.js","../lib/fetch.js","../lib/errors/ExportError.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message about Zod issues with the validation. Optionally,\r\n * a custom message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - The array of Zod issues.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n */\r\nexport function logZodIssues(newLevel, issues = [], customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage} - the following Zod issues occured:`,\r\n      ...issues.map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || '';\r\n    logging.file = file || '';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', 'false', 'undefined', 'null', and ''. The strings\r\n   * 'undefined', 'null', and '' will be transformed to null, the string 'true'\r\n   * will be transformed to the boolean value true, and 'false' will\r\n   * be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', 'false', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The string contains a forbidden value`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: `The value must be numeric and positive`\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: `The value must be numeric and non-negative`\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              value.indexOf('<svg') >= 0 ||\r\n              value.indexOf('<?xml') >= 0 ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that contains '<svg' or '<?xml' or starts with '{' and ends with '}'`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with '.json' or starts with '{' and ends with '}'`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst config = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .json or .svg`\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .json or .svg`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that contains '<svg' or '<?xml'`\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that starts with '{' and ends with '}`\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that ends with '.json'`\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that ends with .json `\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: `The value must be a string that ends with '.log'`\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return (\r\n      z\r\n        .string()\r\n        /// TO DO: Correct\r\n        .uuid({ message: 'The value must be a stringified UUID' })\r\n        .nullable()\r\n    );\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: config.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: config.version(strictCheck),\r\n      cdnUrl: config.cdnUrl(strictCheck),\r\n      forceFetch: config.forceFetch(strictCheck),\r\n      cachePath: config.cachePath(strictCheck),\r\n      coreScripts: config.coreScripts(strictCheck),\r\n      moduleScripts: config.moduleScripts(strictCheck),\r\n      indicatorScripts: config.indicatorScripts(strictCheck),\r\n      customScripts: config.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: config.infile(strictCheck),\r\n      instr: config.instr(),\r\n      options: config.options(),\r\n      svg: config.svg(),\r\n      outfile: config.outfile(strictCheck),\r\n      type: config.type(strictCheck),\r\n      constr: config.constr(strictCheck),\r\n      b64: config.b64(strictCheck),\r\n      noDownload: config.noDownload(strictCheck),\r\n      defaultHeight: config.defaultHeight(strictCheck),\r\n      defaultWidth: config.defaultWidth(strictCheck),\r\n      defaultScale: config.defaultScale(strictCheck),\r\n      height: config.height(strictCheck),\r\n      width: config.width(strictCheck),\r\n      scale: config.scale(strictCheck),\r\n      globalOptions: config.globalOptions(),\r\n      themeOptions: config.themeOptions(),\r\n      batch: config.batch(false),\r\n      rasterizationTimeout: config.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: config.allowCodeExecution(strictCheck),\r\n      allowFileResources: config.allowFileResources(strictCheck),\r\n      customCode: config.customCode(false),\r\n      callback: config.callback(false),\r\n      resources: config.resources(strictCheck),\r\n      loadConfig: config.loadConfig(false),\r\n      createConfig: config.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: config.proxyHost(false),\r\n      port: config.proxyPort(strictCheck),\r\n      timeout: config.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableRateLimiting(strictCheck),\r\n      maxRequests: config.maxRequests(strictCheck),\r\n      window: config.window(strictCheck),\r\n      delay: config.delay(strictCheck),\r\n      trustProxy: config.trustProxy(strictCheck),\r\n      skipKey: config.skipKey(false),\r\n      skipToken: config.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableSsl(strictCheck),\r\n      force: config.sslForce(strictCheck),\r\n      port: config.sslPort(strictCheck),\r\n      certPath: config.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: config.enableServer(strictCheck).optional(),\r\n    host: config.host(strictCheck).optional(),\r\n    port: config.port(strictCheck).optional(),\r\n    benchmarking: config.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: config.minWorkers(strictCheck),\r\n      maxWorkers: config.maxWorkers(strictCheck),\r\n      workLimit: config.workLimit(strictCheck),\r\n      acquireTimeout: config.acquireTimeout(strictCheck),\r\n      createTimeout: config.createTimeout(strictCheck),\r\n      destroyTimeout: config.destroyTimeout(strictCheck),\r\n      idleTimeout: config.idleTimeout(strictCheck),\r\n      createRetryInterval: config.createRetryInterval(strictCheck),\r\n      reaperInterval: config.reaperInterval(strictCheck),\r\n      benchmarking: config.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: config.logLevel(strictCheck),\r\n      file: config.logFile(strictCheck),\r\n      dest: config.logDest(strictCheck),\r\n      toConsole: config.logToConsole(strictCheck),\r\n      toFile: config.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableUi(strictCheck),\r\n      route: config.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: config.nodeEnv(strictCheck),\r\n      listenToProcessExits: config.listenToProcessExits(strictCheck),\r\n      noLogo: config.noLogo(strictCheck),\r\n      hardResetPage: config.hardResetPage(strictCheck),\r\n      browserShellMode: config.browserShellMode(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: config.enableDebug(strictCheck),\r\n      headless: config.headless(strictCheck),\r\n      devtools: config.devtools(strictCheck),\r\n      listenToConsole: config.listenToConsole(strictCheck),\r\n      dumpio: config.dumpio(strictCheck),\r\n      slowMo: config.slowMo(strictCheck),\r\n      debuggingPort: config.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n////\r\n// // Schema for the payload section of options\r\n// const PayloadSchema = () =>\r\n//   z\r\n//     .object({\r\n//       requestId: config.requestId()\r\n//     })\r\n//     .partial();\r\n////\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n  //// payload: PayloadSchema()\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n  //// payload: PayloadSchema()\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: config.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: config.version(false),\r\n  HIGHCHARTS_CDN_URL: config.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: config.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: config.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: config.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: config.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: config.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: config.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: config.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: config.infile(false),\r\n  EXPORT_INSTR: config.instr(),\r\n  EXPORT_OPTIONS: config.options(),\r\n  EXPORT_SVG: config.svg(),\r\n  EXPORT_BATCH: config.batch(false),\r\n  EXPORT_OUTFILE: config.outfile(false),\r\n  EXPORT_TYPE: config.type(false),\r\n  EXPORT_CONSTR: config.constr(false),\r\n  EXPORT_B64: config.b64(false),\r\n  EXPORT_NO_DOWNLOAD: config.noDownload(false),\r\n  EXPORT_HEIGHT: config.height(false),\r\n  EXPORT_WIDTH: config.width(false),\r\n  EXPORT_SCALE: config.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: config.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: config.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: config.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: config.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: config.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: config.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: config.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: config.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: config.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: config.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: config.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: config.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: config.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: config.enableServer(false),\r\n  SERVER_HOST: config.host(false),\r\n  SERVER_PORT: config.port(false),\r\n  SERVER_UPLOAD_LIMIT: config.uploadLimit(false),\r\n  SERVER_BENCHMARKING: config.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: config.proxyHost(false),\r\n  SERVER_PROXY_PORT: config.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: config.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: config.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: config.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: config.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: config.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: config.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: config.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: config.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: config.enableSsl(false),\r\n  SERVER_SSL_FORCE: config.sslForce(false),\r\n  SERVER_SSL_PORT: config.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: config.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: config.minWorkers(false),\r\n  POOL_MAX_WORKERS: config.maxWorkers(false),\r\n  POOL_WORK_LIMIT: config.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: config.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: config.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: config.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: config.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: config.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: config.reaperInterval(false),\r\n  POOL_BENCHMARKING: config.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: config.logLevel(false),\r\n  LOGGING_FILE: config.logFile(false),\r\n  LOGGING_DEST: config.logDest(false),\r\n  LOGGING_TO_CONSOLE: config.logToConsole(false),\r\n  LOGGING_TO_FILE: config.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: config.enableUi(false),\r\n  UI_ROUTE: config.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: config.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: config.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: config.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: config.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: config.browserShellMode(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: config.enableDebug(false),\r\n  DEBUG_HEADLESS: config.headless(false),\r\n  DEBUG_DEVTOOLS: config.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: config.listenToConsole(false),\r\n  DEBUG_DUMPIO: config.dumpio(false),\r\n  DEBUG_SLOW_MO: config.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: config.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates a provided option using the specific validator from the config\r\n * object.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of an option to validate.\r\n * @param {any} option - The option to validate.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {any} The parsed and validated option value.\r\n */\r\nexport function validateOption(name, option, strictCheck) {\r\n  return config[name](strictCheck).parse(option);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate,\r\n  validateOption\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport { envs, looseValidate, strictValidate } from './validation.js';\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n  return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.<string>} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n  // Object for options loaded via the `loadConfig` option\r\n  let configOptions = {};\r\n\r\n  // Object for options from the CLI\r\n  let cliOptions = {};\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs.length) {\r\n    try {\r\n      // Validate options from the custom JSON loaded via the `loadConfig`\r\n      configOptions = strictValidate(_loadConfigFile(cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[config] Custom JSON options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Apply custom options if there are any\r\n  if (customOptions && Object.keys(customOptions).length !== 0) {\r\n    try {\r\n      // Validate custom options provided by the user\r\n      customOptions = strictValidate(customOptions);\r\n    } catch (error) {\r\n      logZodIssues(1, error.issues, '[config] Custom options validation error');\r\n    }\r\n  }\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs.length) {\r\n    try {\r\n      // Validate options from the CLI\r\n      cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(1, error.issues, '[config] CLI options validation error');\r\n    }\r\n  }\r\n\r\n  // Update values of the global options with values from each source possible\r\n  _updateGlobalOptions(\r\n    defaultConfig,\r\n    globalOptions,\r\n    configOptions,\r\n    cliOptions,\r\n    customOptions\r\n  );\r\n\r\n  // Return updated global options\r\n  return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n  // Check if options need to be created for a new instance\r\n  if (newInstance) {\r\n    // Get rid of the old instance options\r\n    Object.keys(instanceOptions).forEach((key) => {\r\n      delete instanceOptions[key];\r\n    });\r\n\r\n    // Init the new instance options based on the global options\r\n    mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n  }\r\n\r\n  // Merge additional options to the instance options\r\n  mergeOptions(instanceOptions, updateOptions);\r\n\r\n  // Return the reference to the instance options object\r\n  return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty array.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n        .bold.yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[item.envLink];\r\n      if (envVal !== undefined && envVal !== null) {\r\n        options[name] = envVal;\r\n      } else {\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      options[name] = _initGlobalOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the config entry of a specific option\r\n    const entry = config[key];\r\n\r\n    // Gather values for the options from every possible source, if exists\r\n    const configVal = configOpt && configOpt[key];\r\n    const cliVal = cliOpt && cliOpt[key];\r\n    const customVal = customOpt && customOpt[key];\r\n\r\n    // If the value not found, need to go deeper\r\n    if (typeof entry.value === 'undefined') {\r\n      _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n    } else {\r\n      // If a value from custom JSON options exists, it takes precedence\r\n      if (configVal !== undefined && configVal !== null) {\r\n        options[key] = configVal;\r\n      }\r\n\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[entry.envLink];\r\n      if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n        options[key] = envVal;\r\n      }\r\n\r\n      // If a value from CLI options exists, it takes precedence\r\n      if (cliVal !== undefined && cliVal !== null) {\r\n        options[key] = cliVal;\r\n      }\r\n\r\n      // If a value from user options exists, it takes precedence\r\n      if (customVal !== undefined && customVal !== null) {\r\n        options[key] = customVal;\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n  // Check if the `loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `loadConfig` is present and has a correct value\r\n  if (configFileName && customLogicOptions.allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        customLogicOptions.allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  setGlobalOptions,\r\n  updateOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules.\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = extractVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Get the reference to the global options to update to the new version\r\n  const options = getOptions();\r\n\r\n  // Set to the new version\r\n  options.highcharts.version = newVersion;\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: join(__dirname, cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const result = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { getOptions, isAllowedConfig, mergeOptions } from './config.js';\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  deepCopy,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  isObject,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\nimport { strictValidate, validateOption } from './validation.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n  try {\r\n    // Check if provided options is an object\r\n    if (!isObject(exportingOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = mergeOptions(deepCopy(getOptions()), {\r\n      export: exportingOptions.export,\r\n      customLogic: exportingOptions.customLogic\r\n    });\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        try {\r\n          // Set to the `svg` option\r\n          exportOptions.svg = validateOption('svg', fileContent, false);\r\n        } catch (error) {\r\n          logZodIssues(\r\n            1,\r\n            error.issues,\r\n            '[config] The `svg` option validation error'\r\n          );\r\n          throw error;\r\n        }\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        try {\r\n          // Set to the `instr` option\r\n          exportOptions.instr = validateOption('instr', fileContent, false);\r\n        } catch (error) {\r\n          logZodIssues(\r\n            1,\r\n            error.issues,\r\n            '[config] The `instr` option validation error'\r\n          );\r\n          throw error;\r\n        }\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // The last strict validation of options right before exporting process\r\n  try {\r\n    // Validate final options\r\n    options = strictValidate(options);\r\n  } catch (error) {\r\n    logZodIssues(1, error.issues, '[config] Final options validation error');\r\n  }\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled\r\n    if (rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n  fixConstr,\r\n  fixType,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    try {\r\n      // Validate options from the body and store parsed structure in the request\r\n      request.validatedOptions = looseValidate({\r\n        // Set the created ID as a `_requestId` property in the validated options\r\n        _requestId: requestId,\r\n        export: {\r\n          instr,\r\n          svg: body.svg,\r\n          outfile:\r\n            body.outfile ||\r\n            `${request.params.filename || 'chart'}.${fixType(body.type)}`,\r\n          type: fixType(body.type, body.outfile),\r\n          constr: fixConstr(body.constr),\r\n          b64: body.b64,\r\n          noDownload: body.noDownload,\r\n          height: body.height,\r\n          width: body.width,\r\n          scale: body.scale,\r\n          globalOptions: isAllowedConfig(\r\n            body.globalOptions,\r\n            true,\r\n            allowCodeExecution\r\n          ),\r\n          themeOptions: isAllowedConfig(\r\n            body.themeOptions,\r\n            true,\r\n            allowCodeExecution\r\n          )\r\n        },\r\n        customLogic: {\r\n          allowCodeExecution,\r\n          allowFileResources: false,\r\n          customCode: body.customCode,\r\n          callback: body.callback,\r\n          resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n        }\r\n      });\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[config] Request options validation error'\r\n      );\r\n\r\n      throw new ExportError(\r\n        'The provided options are not correct. Please check if your data is of the correct types.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      log(4, '[ui] Returning UI for the export.');\r\n\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      let newVersion = request.params.newVersion;\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      server: serverOptions\r\n    });\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions({\r\n    server: {\r\n      rateLimiting: rateLimitingOptions\r\n    }\r\n  });\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n  // Init and update the instance options object\r\n  const options = updateOptions(initOptions, true);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        level\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        toConsole\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        dest,\r\n        file,\r\n        toFile\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","indexOf","object","passthrough","additionalOptions","adminToken","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","validateOption","name","option","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","Error","customLogicOptions","configIndex","findIndex","arg","i","async","fetch","url","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","ExportError","constructor","statusCode","super","setStatus","setError","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","_requestId","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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AAmB,iBACzC0D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBC,cAAe,CACbvE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YAC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"} +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),promises=require("fs/promises"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?e:path.join(__dirname$1,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),i=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):zod.z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>zod.z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initGlobalOptions(defaultConfig),instanceOptions=deepCopy(globalOptions);function getOptions(e=!0){return e?instanceOptions:globalOptions}function setGlobalOptions(e={},t=[]){let o={},r={};if(t&&Array.isArray(t)&&t.length){try{o=strictValidate(_loadConfigFile(t,globalOptions.customLogic))}catch(e){logZodIssues(1,e.issues,"[validation] Custom options from the `loadConfig` option validation error")}try{r=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[validation] CLI options validation error")}}if(e&&isObject(e)&&Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[validation] Custom options validation error")}return _updateGlobalOptions(defaultConfig,globalOptions,o,r,e),globalOptions}function updateOptions(e,t=!1){return t&&(Object.keys(instanceOptions).forEach((e=>{delete instanceOptions[e]})),mergeOptions(instanceOptions,deepCopy(globalOptions))),mergeOptions(instanceOptions,e),instanceOptions}function mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,r]of Object.entries(e))if(Object.prototype.hasOwnProperty.call(r,"value")){const e=envs[r.envLink];t[o]=null!=e?e:r.value}else t[o]=_initGlobalOptions(r);return t}function _updateGlobalOptions(e,t,o,r,i){Object.keys(e).forEach((n=>{const s=e[n],a=o&&o[n],l=r&&r[n],c=i&&i[n];if(void 0===s.value)_updateGlobalOptions(s,t[n],a,l,c);else{null!=a&&(t[n]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[n]=e),null!=l&&(t[n]=l),null!=c&&(t[n]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e,t){const o=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),r=o>-1&&e[o+1];if(r&&t.allowFileResources)try{return isAllowedConfig(fs.readFileSync(getAbsolutePath(r),"utf8"),!1,t.allowCodeExecution)}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${r} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let r=0;r{if(n.length-1===s){const n=t[++r];n||log(2,`[config] Missing value for the CLI '--${i}' argument. Using the default value.`),e[o]=n||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),i=path.join(r,"manifest.json"),n=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(fs.readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await fetch(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,i){let n;const s=r.host,a=r.port;if(s&&a)try{n=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=n?{agent:n,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,i,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,i))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,i=e.cdnUrl||cache.cdnUrl;try{const n={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${i}/${r}/${e}`:`${i}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`))],e.customScripts,t,n),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),n}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=i(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){let i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:path.join(__dirname$1,e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=i?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const i=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${i()}ms.`).setError(n);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${i()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);e=validateOptions(e),await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):fs.writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{e=validateOptions(e);const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):fs.writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.",400);const o=mergeOptions(deepCopy(getOptions()),{export:e.export,customLogic:e.customLogic}),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let i=e,n=!1;if(t&&e.endsWith(".json"))try{i=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else i=isAllowedConfig(e,!1,o),i&&!t&&delete i.files;for(const e in i)r.includes(e)?n||(n=!0):delete i[e];return n?(i.files&&(i.files=i.files.map((e=>e.trim())),(!i.files||i.files.length<=0)&&delete i.files),i=validateOption("resources",i),i):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions=validateOptions({requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}}),o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let i=e.params.newVersion;try{i=validateOption("version",e.params.newVersion)}catch(e){throw new ExportError(`[version] Version is incorrect: ${e.message}`,400).setError(e)}if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions(validateOptions({server:e}));if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions(validateOptions({server:{rateLimiting:e}}));rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(validateOptions(e),!0);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,setGlobalOptions:setGlobalOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions(validateOptions({logging:{level:e}})).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions(validateOptions({logging:{toConsole:e}})).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions(validateOptions({logging:{dest:e,file:t,toFile:o}}));enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};exports.default=index,exports.initExport=initExport; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || '';\r\n    logging.file = file || '';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n  return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.<string>} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n  // Object for options loaded via the `loadConfig` option\r\n  let configOptions = {};\r\n\r\n  // Object for options from the CLI\r\n  let cliOptions = {};\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Validate options from the custom JSON loaded via the `loadConfig`\r\n      configOptions = strictValidate(\r\n        _loadConfigFile(cliArgs, globalOptions.customLogic)\r\n      );\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options from the `loadConfig` option validation error'\r\n      );\r\n    }\r\n\r\n    try {\r\n      // Validate options from the CLI\r\n      cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] CLI options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Apply custom options if there are any\r\n  if (\r\n    customOptions &&\r\n    isObject(customOptions) &&\r\n    Object.keys(customOptions).length\r\n  ) {\r\n    try {\r\n      // Validate custom options provided by the user\r\n      customOptions = strictValidate(customOptions);\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Update values of the global options with values from each source possible\r\n  _updateGlobalOptions(\r\n    defaultConfig,\r\n    globalOptions,\r\n    configOptions,\r\n    cliOptions,\r\n    customOptions\r\n  );\r\n\r\n  // Return updated global options\r\n  return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n  // Check if options need to be created for a new instance\r\n  if (newInstance) {\r\n    // Get rid of the old instance options\r\n    Object.keys(instanceOptions).forEach((key) => {\r\n      delete instanceOptions[key];\r\n    });\r\n\r\n    // Init the new instance options based on the global options\r\n    mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n  }\r\n\r\n  // Merge additional options to the instance options\r\n  mergeOptions(instanceOptions, updateOptions);\r\n\r\n  // Return the reference to the instance options object\r\n  return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty array.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n        .bold.yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[item.envLink];\r\n      if (envVal !== undefined && envVal !== null) {\r\n        options[name] = envVal;\r\n      } else {\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      options[name] = _initGlobalOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the config entry of a specific option\r\n    const entry = config[key];\r\n\r\n    // Gather values for the options from every possible source, if exists\r\n    const configVal = configOpt && configOpt[key];\r\n    const cliVal = cliOpt && cliOpt[key];\r\n    const customVal = customOpt && customOpt[key];\r\n\r\n    // If the value not found, need to go deeper\r\n    if (typeof entry.value === 'undefined') {\r\n      _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n    } else {\r\n      // If a value from custom JSON options exists, it takes precedence\r\n      if (configVal !== undefined && configVal !== null) {\r\n        options[key] = configVal;\r\n      }\r\n\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[entry.envLink];\r\n      if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n        options[key] = envVal;\r\n      }\r\n\r\n      // If a value from CLI options exists, it takes precedence\r\n      if (cliVal !== undefined && cliVal !== null) {\r\n        options[key] = cliVal;\r\n      }\r\n\r\n      // If a value from user options exists, it takes precedence\r\n      if (customVal !== undefined && customVal !== null) {\r\n        options[key] = customVal;\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n  // Check if the `loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `loadConfig` is present and has a correct value\r\n  if (configFileName && customLogicOptions.allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        customLogicOptions.allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  setGlobalOptions,\r\n  updateOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules.\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = extractVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Get the reference to the global options to update to the new version\r\n  const options = getOptions();\r\n\r\n  // Set to the new version\r\n  options.highcharts.version = newVersion;\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: join(__dirname, cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const result = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n  getOptions,\r\n  isAllowedConfig,\r\n  mergeOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  deepCopy,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  isObject,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Validate single export options\r\n    options = validateOptions(options);\r\n\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // Validate batch export options\r\n    options = validateOptions(options);\r\n\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n  try {\r\n    // Check if provided options is an object\r\n    if (!isObject(exportingOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = mergeOptions(deepCopy(getOptions()), {\r\n      export: exportingOptions.export,\r\n      customLogic: exportingOptions.customLogic\r\n    });\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Validate option\r\n  handledResources = validateOption('resources', handledResources);\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled\r\n    if (rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n  fixConstr,\r\n  fixType,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Validate the request options and store parsed structure in the request\r\n    request.validatedOptions = validateOptions({\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    });\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      log(4, '[ui] Returning UI for the export.');\r\n\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      let newVersion = request.params.newVersion;\r\n\r\n      // Validate the version\r\n      try {\r\n        newVersion = validateOption('version', request.params.newVersion);\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          `[version] Version is incorrect: ${error.message}`,\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // When a correct value found\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        server: serverOptions\r\n      })\r\n    );\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions(\r\n    validateOptions({\r\n      server: {\r\n        rateLimiting: rateLimitingOptions\r\n      }\r\n    })\r\n  );\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n  // Init, validate and update the instance options object\r\n  const options = updateOptions(validateOptions(initOptions), true);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          level\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          toConsole\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          dest,\r\n          file,\r\n          toFile\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","customLogicOptions","configIndex","findIndex","arg","configFileName","i","option","async","fetch","url","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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aAAc,kBAAmB,iBACzC0D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBC,cAAe,CACbvE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eA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"} diff --git a/dist/index.esm.js b/dist/index.esm.js index f712f11f..6e43222d 100644 --- a/dist/index.esm.js +++ b/dist/index.esm.js @@ -1,2 +1,2 @@ -import"colors";import{readFileSync,existsSync,mkdirSync,appendFile,writeFileSync}from"fs";import{isAbsolute,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import{readFile}from"fs/promises";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},n=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":n.includes(o)&&e!==o&&(e=o)}return o[e]||n.find((t=>t===e))||"png"}function getAbsolutePath(e){return isAbsolute(e)?e:join(__dirname,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:n,level:r}=logging;if(5!==t&&(0===t||t>r||r>n.length))return;const i=`${getNewDate()} [${n[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const n=o||t&&t.message||"",{level:r,levelsDesc:i}=logging;if(0===e||e>r||r>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t&&t.stack,l=[n];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t=[],o){logWithStack(e,null,[`${o} - the following Zod issues occured:`,...t.map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:n,toConsole:r,toFile:i}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(r),enableFileLogging(o,n,i)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((n=>{const r=e[n];void 0===r.value?_createNestedProps(r,t,`${o}.${n}`):(t[r.cliName||n]=`${o}.${n}`.substring(1),void 0!==r.legacyName&&(t[r.legacyName]=`${o}.${n}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const n=e[o];void 0===n.types?_createAbsoluteProps(n,t):n.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","false","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const n=z.string().trim().array(),r=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?n.transform(i):z.union([r,n]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},config={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),n=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json'"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,n]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json "}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with '.log'"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:config.args(e)}).partial(),HighchartsSchema=e=>z.object({version:config.version(e),cdnUrl:config.cdnUrl(e),forceFetch:config.forceFetch(e),cachePath:config.cachePath(e),coreScripts:config.coreScripts(e),moduleScripts:config.moduleScripts(e),indicatorScripts:config.indicatorScripts(e),customScripts:config.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:config.infile(e),instr:config.instr(),options:config.options(),svg:config.svg(),outfile:config.outfile(e),type:config.type(e),constr:config.constr(e),b64:config.b64(e),noDownload:config.noDownload(e),defaultHeight:config.defaultHeight(e),defaultWidth:config.defaultWidth(e),defaultScale:config.defaultScale(e),height:config.height(e),width:config.width(e),scale:config.scale(e),globalOptions:config.globalOptions(),themeOptions:config.themeOptions(),batch:config.batch(!1),rasterizationTimeout:config.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:config.allowCodeExecution(e),allowFileResources:config.allowFileResources(e),customCode:config.customCode(!1),callback:config.callback(!1),resources:config.resources(e),loadConfig:config.loadConfig(!1),createConfig:config.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:config.proxyHost(!1),port:config.proxyPort(e),timeout:config.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:config.enableRateLimiting(e),maxRequests:config.maxRequests(e),window:config.window(e),delay:config.delay(e),trustProxy:config.trustProxy(e),skipKey:config.skipKey(!1),skipToken:config.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:config.enableSsl(e),force:config.sslForce(e),port:config.sslPort(e),certPath:config.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:config.enableServer(e).optional(),host:config.host(e).optional(),port:config.port(e).optional(),benchmarking:config.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:config.minWorkers(e),maxWorkers:config.maxWorkers(e),workLimit:config.workLimit(e),acquireTimeout:config.acquireTimeout(e),createTimeout:config.createTimeout(e),destroyTimeout:config.destroyTimeout(e),idleTimeout:config.idleTimeout(e),createRetryInterval:config.createRetryInterval(e),reaperInterval:config.reaperInterval(e),benchmarking:config.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:config.logLevel(e),file:config.logFile(e),dest:config.logDest(e),toConsole:config.logToConsole(e),toFile:config.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:config.enableUi(e),route:config.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:config.nodeEnv(e),listenToProcessExits:config.listenToProcessExits(e),noLogo:config.noLogo(e),hardResetPage:config.hardResetPage(e),browserShellMode:config.browserShellMode(e)}).partial(),DebugSchema=e=>z.object({enable:config.enableDebug(e),headless:config.headless(e),devtools:config.devtools(e),listenToConsole:config.listenToConsole(e),dumpio:config.dumpio(e),slowMo:config.slowMo(e),debuggingPort:config.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:config.args(!1),HIGHCHARTS_VERSION:config.version(!1),HIGHCHARTS_CDN_URL:config.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:config.forceFetch(!1),HIGHCHARTS_CACHE_PATH:config.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:config.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:config.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:config.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:config.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:config.customScripts(!1),EXPORT_INFILE:config.infile(!1),EXPORT_INSTR:config.instr(),EXPORT_OPTIONS:config.options(),EXPORT_SVG:config.svg(),EXPORT_BATCH:config.batch(!1),EXPORT_OUTFILE:config.outfile(!1),EXPORT_TYPE:config.type(!1),EXPORT_CONSTR:config.constr(!1),EXPORT_B64:config.b64(!1),EXPORT_NO_DOWNLOAD:config.noDownload(!1),EXPORT_HEIGHT:config.height(!1),EXPORT_WIDTH:config.width(!1),EXPORT_SCALE:config.scale(!1),EXPORT_DEFAULT_HEIGHT:config.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:config.defaultWidth(!1),EXPORT_DEFAULT_SCALE:config.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:config.globalOptions(),EXPORT_THEME_OPTIONS:config.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:config.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:config.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:config.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:config.customCode(!1),CUSTOM_LOGIC_CALLBACK:config.callback(!1),CUSTOM_LOGIC_RESOURCES:config.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:config.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:config.createConfig(!1),SERVER_ENABLE:config.enableServer(!1),SERVER_HOST:config.host(!1),SERVER_PORT:config.port(!1),SERVER_UPLOAD_LIMIT:config.uploadLimit(!1),SERVER_BENCHMARKING:config.serverBenchmarking(!1),SERVER_PROXY_HOST:config.proxyHost(!1),SERVER_PROXY_PORT:config.proxyPort(!1),SERVER_PROXY_TIMEOUT:config.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:config.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:config.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:config.window(!1),SERVER_RATE_LIMITING_DELAY:config.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:config.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:config.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:config.skipToken(!1),SERVER_SSL_ENABLE:config.enableSsl(!1),SERVER_SSL_FORCE:config.sslForce(!1),SERVER_SSL_PORT:config.sslPort(!1),SERVER_SSL_CERT_PATH:config.sslCertPath(!1),POOL_MIN_WORKERS:config.minWorkers(!1),POOL_MAX_WORKERS:config.maxWorkers(!1),POOL_WORK_LIMIT:config.workLimit(!1),POOL_ACQUIRE_TIMEOUT:config.acquireTimeout(!1),POOL_CREATE_TIMEOUT:config.createTimeout(!1),POOL_DESTROY_TIMEOUT:config.destroyTimeout(!1),POOL_IDLE_TIMEOUT:config.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:config.createRetryInterval(!1),POOL_REAPER_INTERVAL:config.reaperInterval(!1),POOL_BENCHMARKING:config.poolBenchmarking(!1),LOGGING_LEVEL:config.logLevel(!1),LOGGING_FILE:config.logFile(!1),LOGGING_DEST:config.logDest(!1),LOGGING_TO_CONSOLE:config.logToConsole(!1),LOGGING_TO_FILE:config.logToFile(!1),UI_ENABLE:config.enableUi(!1),UI_ROUTE:config.uiRoute(!1),OTHER_NODE_ENV:config.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:config.listenToProcessExits(!1),OTHER_NO_LOGO:config.noLogo(!1),OTHER_HARD_RESET_PAGE:config.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:config.browserShellMode(!1),DEBUG_ENABLE:config.enableDebug(!1),DEBUG_HEADLESS:config.headless(!1),DEBUG_DEVTOOLS:config.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:config.listenToConsole(!1),DEBUG_DUMPIO:config.dumpio(!1),DEBUG_SLOW_MO:config.slowMo(!1),DEBUG_DEBUGGING_PORT:config.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function validateOption(e,t,o){return config[e](o).parse(t)}function _customErrorMap(e,t){const o=e.path.join("."),n=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${n} - No value was provided.`}:{message:`${n} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${n} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${n} - ${t.defaultError}.`}}const globalOptions=_initGlobalOptions(defaultConfig),instanceOptions=deepCopy(globalOptions);function getOptions(e=!0){return e?instanceOptions:globalOptions}function setGlobalOptions(e={},t=[]){let o={},n={};if(t.length)try{o=strictValidate(_loadConfigFile(t))}catch(e){logZodIssues(1,e.issues,"[config] Custom JSON options validation error")}if(e&&0!==Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Custom options validation error")}if(t.length)try{n=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[config] CLI options validation error")}return _updateGlobalOptions(defaultConfig,globalOptions,o,n,e),globalOptions}function updateOptions(e,t=!1){return t&&(Object.keys(instanceOptions).forEach((e=>{delete instanceOptions[e]})),mergeOptions(instanceOptions,deepCopy(globalOptions))),mergeOptions(instanceOptions,e),instanceOptions}function mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,n]of Object.entries(t))e[o]=isObject(n)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],n):void 0!==n?n:e[o]||null;return e}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,n]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,r)=>t[o]=e.length-1===r?n:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,n]of Object.entries(e))if(Object.prototype.hasOwnProperty.call(n,"value")){const e=envs[n.envLink];t[o]=null!=e?e:n.value}else t[o]=_initGlobalOptions(n);return t}function _updateGlobalOptions(e,t,o,n,r){Object.keys(e).forEach((i=>{const s=e[i],a=o&&o[i],l=n&&n[i],c=r&&r[i];if(void 0===s.value)_updateGlobalOptions(s,t[i],a,l,c);else{null!=a&&(t[i]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[i]=e),null!=l&&(t[i]=l),null!=c&&(t[i]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,n)=>{if("string"==typeof n&&(n=n.trim()),"function"==typeof n||"string"==typeof n&&n.startsWith("function")&&n.endsWith("}")){if(t)return o?`"EXP_FUN${(n+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(n+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return n})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e,t){const o=e.findIndex((e=>"loadConfig"===e.replace(/-/g,"")));return o>-1&&e[o+1]&&t.allowFileResources,{}}function _pairArgumentValue(e,t){const o={};for(let n=0;n{if(i.length-1===s){const i=t[++n];i||log(2,`[config] Missing value for the CLI '--${r}' argument. Using the default value.`),e[o]=i||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,n)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||n("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{n(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const n=getCachePath(),r=join(n,"manifest.json"),i=join(n,"sources.js");if(!existsSync(n)&&mkdirSync(n,{recursive:!0}),!existsSync(r)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let n=!1;const s=JSON.parse(readFileSync(r),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),n=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),n=!0):n=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),n?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,n=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const r=await fetch(`${e}.js`,t);if(200===r.statusCode&&"string"==typeof r.text){if(o){o[extractModuleName(e)]=1}return r.text}if(n)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${r.statusCode}).`,404).setError(r);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,n,r){let i;const s=n.host,a=n.port;if(s&&a)try{i=new HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:n.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,r,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,r))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const n="latest"===e.version?null:`${e.version}`,r=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${n||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>n?`${r}/${n}/${e}`:`${r}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?n?`${r}/maps/${n}/modules/${e}`:`${r}/maps/modules/${e}`:n?`${r}/${n}/modules/${e}`:`${r}/modules/${e}`)),...e.indicatorScripts.map((e=>n?`${r}/stock/${n}/indicators/${e}`:`${r}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:n,merge:r,wrap:i}=Highcharts;Highcharts.setOptionsObj=r(!1,{},o()),window.isRenderComplete=!1,i(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=r(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),i(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=r(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&n(c),Highcharts[e.constr]("container",p,u);const g=o();for(const e in g)"function"!=typeof g[e]&&delete g[e];n(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:n,...r}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...n&&r};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),n&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],n=t.resources;if(n){const r=[];if(n.js&&r.push({content:n.js}),n.files)for(const e of n.files){const t=!e.startsWith("http");r.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of r)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}r.length=0;const i=[];if(n.css){let r=n.css.match(/@import\s*([^;]*);/g);if(r)for(let e of r)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:join(__dirname,e)}));i.push({content:n.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const n of[...e,...t,...o])n.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const n=[];try{let r=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;r=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);n.push(...await addPageResources(e,o));const i=r?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,n=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:n}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||t.height)),c=Math.abs(Math.ceil(i.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:r?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,n),p}catch(t){return await clearPageResources(e,n),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:n,height:r}=e.getBoundingClientRect();return{x:t,y:o,width:n,height:Math.trunc(r>1?r:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,n){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),n||1500)))])}async function _createPDF(e,t,o,n){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:n||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const n=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),i=await puppeteerExport(t.page,e.export,e.customLogic);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(i):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${r()}ms.`).setError(i);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t);const s=getNewDateTime()-n;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:n,allCreated:r,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${n}.`),log(5,`[pool] The number of all created (used and free) resources: ${r}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:n,type:r}=t.options.export;try{o?writeFileSync(`${n.split(".").shift()||"chart"}.txt`,getBase64(t.result,r)):writeFileSync(n||`chart.${r}`,"svg"!==r?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:n,type:r}=t.options.export;try{o?writeFileSync(`${n.split(".").shift()||"chart"}.txt`,getBase64(t.result,r)):writeFileSync(n,"svg"!==r?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.",400);const o=mergeOptions(deepCopy(getOptions()),{export:e.export,customLogic:e.customLogic}),n=o.export;if(log(4,"[chart] Starting the exporting process."),null!==n.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(n.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(n.infile.endsWith(".svg"))try{n.svg=validateOption("svg",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `svg` option validation error"),e}else{if(!n.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);try{n.instr=validateOption("instr",e,!1)}catch(e){throw logZodIssues(1,e.issues,"[config] The `instr` option validation error"),e}}}if(null!==n.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(n.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==n.instr||null!==n.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(n.instr||n.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)};try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[config] Final options validation error")}return postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:n,exporting:r}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||r?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||r?.sourceHeight||n?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||r?.sourceWidth||n?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const n=["js","css","files"];let r=e,i=!1;if(t&&e.endsWith(".json"))try{r=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files;for(const e in r)n.includes(e)?i||(i=!0):delete r[e];return i?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((n=>{try{e[n]&&(t&&"string"==typeof e[n]&&e[n].endsWith(".json")?e[n]=isAllowedConfig(readFileSync(getAbsolutePath(e[n]),"utf8"),!0,o):e[n]=isAllowedConfig(e[n],!0,o))}catch(t){logWithStack(2,t,`[chart] The \`${n}\` cannot be loaded.`),e[n]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,n){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,n(e)}function returnErrorMiddleware(e,t,o,n){const{message:r,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:r,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",n={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};n.trustProxy&&e.enable("trust proxy");const r=rateLimit({windowMs:60*n.window*1e3,limit:n.maxRequests,delayMs:n.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==n.skipKey&&null!==n.skipToken&&e.query.key===n.skipKey&&e.query.access_token===n.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(r),log(3,`[rate limiting] Enabled rate limiting with ${n.maxRequests} requests per ${n.window} minute for each IP, trusting proxy: ${n.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,n=v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${n}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${n}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const r=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,r);if(null===i&&!t.svg)throw log(2,`[validation] Request [${n}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${n}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${n}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);try{e.validatedOptions=looseValidate({_requestId:n,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${fixType(t.type)}`,type:fixType(t.type,t.outfile),constr:fixConstr(t.constr),b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,r),themeOptions:isAllowedConfig(t.themeOptions,!0,r)},customLogic:{allowCodeExecution:r,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,r)}})}catch(e){throw logZodIssues(1,e.issues,"[config] Request options validation error"),new ExportError("The provided options are not correct. Please check if your data is of the correct types.",400)}return o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let n=!1;e.socket.on("close",(e=>{e&&(n=!0)}));const r=e.validatedOptions,i=r.requestId;log(4,`[export] Request [${i}] - Got an incoming HTTP request.`),await startExport(r,((r,s)=>{if(e.socket.removeAllListeners("close"),n)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(r)throw r;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${i}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:n,noDownload:r,outfile:a}=s.options.export;return n?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),r||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,n=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:n,message:isNaN(n)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${n.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const n=e.get("hc-auth");if(!n||n!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let r=e.params.newVersion;if(!r)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(r)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${r}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,n=multer.memoryStorage(),r=multer({storage:n,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(r.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const n=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(n),n.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,n),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(e,!0);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,setGlobalOptions:setGlobalOptions,mapToNewOptions:mapToNewOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const n=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(n.logging.dest,n.logging.file,n.logging.toFile)}};export{index as default,initExport}; +import"colors";import{readFileSync,existsSync,mkdirSync,appendFile,writeFileSync}from"fs";import{isAbsolute,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import{readFile}from"fs/promises";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return isAbsolute(e)?e:join(__dirname,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=z.string().trim().array(),i=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initGlobalOptions(defaultConfig),instanceOptions=deepCopy(globalOptions);function getOptions(e=!0){return e?instanceOptions:globalOptions}function setGlobalOptions(e={},t=[]){let o={},r={};if(t&&Array.isArray(t)&&t.length){try{o=strictValidate(_loadConfigFile(t,globalOptions.customLogic))}catch(e){logZodIssues(1,e.issues,"[validation] Custom options from the `loadConfig` option validation error")}try{r=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[validation] CLI options validation error")}}if(e&&isObject(e)&&Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[validation] Custom options validation error")}return _updateGlobalOptions(defaultConfig,globalOptions,o,r,e),globalOptions}function updateOptions(e,t=!1){return t&&(Object.keys(instanceOptions).forEach((e=>{delete instanceOptions[e]})),mergeOptions(instanceOptions,deepCopy(globalOptions))),mergeOptions(instanceOptions,e),instanceOptions}function mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,r]of Object.entries(e))if(Object.prototype.hasOwnProperty.call(r,"value")){const e=envs[r.envLink];t[o]=null!=e?e:r.value}else t[o]=_initGlobalOptions(r);return t}function _updateGlobalOptions(e,t,o,r,i){Object.keys(e).forEach((n=>{const s=e[n],a=o&&o[n],l=r&&r[n],c=i&&i[n];if(void 0===s.value)_updateGlobalOptions(s,t[n],a,l,c);else{null!=a&&(t[n]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[n]=e),null!=l&&(t[n]=l),null!=c&&(t[n]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e,t){const o=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),r=o>-1&&e[o+1];if(r&&t.allowFileResources)try{return isAllowedConfig(readFileSync(getAbsolutePath(r),"utf8"),!1,t.allowCodeExecution)}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${r} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let r=0;r{if(n.length-1===s){const n=t[++r];n||log(2,`[config] Missing value for the CLI '--${i}' argument. Using the default value.`),e[o]=n||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),i=join(r,"manifest.json"),n=join(r,"sources.js");if(!existsSync(r)&&mkdirSync(r,{recursive:!0}),!existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await fetch(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,i){let n;const s=r.host,a=r.port;if(s&&a)try{n=new HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=n?{agent:n,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,i,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,i))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,i=e.cdnUrl||cache.cdnUrl;try{const n={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${i}/${r}/${e}`:`${i}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`))],e.customScripts,t,n),cache.hcVersion=extractVersion(cache.sources),writeFileSync(o,cache.sources),n}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=i(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){let i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:join(__dirname,e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=i?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const i=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${i()}ms.`).setError(n);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${i()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);e=validateOptions(e),await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{e=validateOptions(e);const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.",400);const o=mergeOptions(deepCopy(getOptions()),{export:e.export,customLogic:e.customLogic}),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let i=e,n=!1;if(t&&e.endsWith(".json"))try{i=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else i=isAllowedConfig(e,!1,o),i&&!t&&delete i.files;for(const e in i)r.includes(e)?n||(n=!0):delete i[e];return n?(i.files&&(i.files=i.files.map((e=>e.trim())),(!i.files||i.files.length<=0)&&delete i.files),i=validateOption("resources",i),i):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions=validateOptions({requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}}),o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let i=e.params.newVersion;try{i=validateOption("version",e.params.newVersion)}catch(e){throw new ExportError(`[version] Version is incorrect: ${e.message}`,400).setError(e)}if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions(validateOptions({server:e}));if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await readFile(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions(validateOptions({server:{rateLimiting:e}}));rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(validateOptions(e),!0);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,setGlobalOptions:setGlobalOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions(validateOptions({logging:{level:e}})).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions(validateOptions({logging:{toConsole:e}})).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions(validateOptions({logging:{dest:e,file:t,toFile:o}}));enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};export{index as default,initExport}; //# sourceMappingURL=index.esm.js.map diff --git a/dist/index.esm.js.map b/dist/index.esm.js.map index 545da11b..dd3f1f3e 100644 --- a/dist/index.esm.js.map +++ b/dist/index.esm.js.map @@ -1 +1 @@ -{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/config.js","../lib/fetch.js","../lib/errors/ExportError.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message about Zod issues with the validation. Optionally,\r\n * a custom message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - The array of Zod issues.\r\n * @param {string} customMessage - An optional custom message to be logged\r\n * along with the error.\r\n */\r\nexport function logZodIssues(newLevel, issues = [], customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage} - the following Zod issues occured:`,\r\n ...issues.map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || '';\r\n logging.file = file || '';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', 'false', 'undefined', 'null', and ''. The strings\r\n * 'undefined', 'null', and '' will be transformed to null, the string 'true'\r\n * will be transformed to the boolean value true, and 'false' will\r\n * be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', 'false', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The string contains a forbidden value`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be numeric and positive`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be numeric and non-negative`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that contains '\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with '.json' or starts with '{' and ends with '}'`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst config = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .json or .svg`\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .json or .svg`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with '{' and ends with '}`\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with '.json'`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with .json `\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that ends with '.log'`\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return (\r\n z\r\n .string()\r\n /// TO DO: Correct\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable()\r\n );\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: config.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: config.version(strictCheck),\r\n cdnUrl: config.cdnUrl(strictCheck),\r\n forceFetch: config.forceFetch(strictCheck),\r\n cachePath: config.cachePath(strictCheck),\r\n coreScripts: config.coreScripts(strictCheck),\r\n moduleScripts: config.moduleScripts(strictCheck),\r\n indicatorScripts: config.indicatorScripts(strictCheck),\r\n customScripts: config.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: config.infile(strictCheck),\r\n instr: config.instr(),\r\n options: config.options(),\r\n svg: config.svg(),\r\n outfile: config.outfile(strictCheck),\r\n type: config.type(strictCheck),\r\n constr: config.constr(strictCheck),\r\n b64: config.b64(strictCheck),\r\n noDownload: config.noDownload(strictCheck),\r\n defaultHeight: config.defaultHeight(strictCheck),\r\n defaultWidth: config.defaultWidth(strictCheck),\r\n defaultScale: config.defaultScale(strictCheck),\r\n height: config.height(strictCheck),\r\n width: config.width(strictCheck),\r\n scale: config.scale(strictCheck),\r\n globalOptions: config.globalOptions(),\r\n themeOptions: config.themeOptions(),\r\n batch: config.batch(false),\r\n rasterizationTimeout: config.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: config.allowCodeExecution(strictCheck),\r\n allowFileResources: config.allowFileResources(strictCheck),\r\n customCode: config.customCode(false),\r\n callback: config.callback(false),\r\n resources: config.resources(strictCheck),\r\n loadConfig: config.loadConfig(false),\r\n createConfig: config.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: config.proxyHost(false),\r\n port: config.proxyPort(strictCheck),\r\n timeout: config.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableRateLimiting(strictCheck),\r\n maxRequests: config.maxRequests(strictCheck),\r\n window: config.window(strictCheck),\r\n delay: config.delay(strictCheck),\r\n trustProxy: config.trustProxy(strictCheck),\r\n skipKey: config.skipKey(false),\r\n skipToken: config.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableSsl(strictCheck),\r\n force: config.sslForce(strictCheck),\r\n port: config.sslPort(strictCheck),\r\n certPath: config.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: config.enableServer(strictCheck).optional(),\r\n host: config.host(strictCheck).optional(),\r\n port: config.port(strictCheck).optional(),\r\n benchmarking: config.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: config.minWorkers(strictCheck),\r\n maxWorkers: config.maxWorkers(strictCheck),\r\n workLimit: config.workLimit(strictCheck),\r\n acquireTimeout: config.acquireTimeout(strictCheck),\r\n createTimeout: config.createTimeout(strictCheck),\r\n destroyTimeout: config.destroyTimeout(strictCheck),\r\n idleTimeout: config.idleTimeout(strictCheck),\r\n createRetryInterval: config.createRetryInterval(strictCheck),\r\n reaperInterval: config.reaperInterval(strictCheck),\r\n benchmarking: config.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: config.logLevel(strictCheck),\r\n file: config.logFile(strictCheck),\r\n dest: config.logDest(strictCheck),\r\n toConsole: config.logToConsole(strictCheck),\r\n toFile: config.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableUi(strictCheck),\r\n route: config.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: config.nodeEnv(strictCheck),\r\n listenToProcessExits: config.listenToProcessExits(strictCheck),\r\n noLogo: config.noLogo(strictCheck),\r\n hardResetPage: config.hardResetPage(strictCheck),\r\n browserShellMode: config.browserShellMode(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: config.enableDebug(strictCheck),\r\n headless: config.headless(strictCheck),\r\n devtools: config.devtools(strictCheck),\r\n listenToConsole: config.listenToConsole(strictCheck),\r\n dumpio: config.dumpio(strictCheck),\r\n slowMo: config.slowMo(strictCheck),\r\n debuggingPort: config.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n////\r\n// // Schema for the payload section of options\r\n// const PayloadSchema = () =>\r\n// z\r\n// .object({\r\n// requestId: config.requestId()\r\n// })\r\n// .partial();\r\n////\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n //// payload: PayloadSchema()\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n //// payload: PayloadSchema()\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: config.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: config.version(false),\r\n HIGHCHARTS_CDN_URL: config.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: config.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: config.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: config.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: config.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: config.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: config.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: config.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: config.infile(false),\r\n EXPORT_INSTR: config.instr(),\r\n EXPORT_OPTIONS: config.options(),\r\n EXPORT_SVG: config.svg(),\r\n EXPORT_BATCH: config.batch(false),\r\n EXPORT_OUTFILE: config.outfile(false),\r\n EXPORT_TYPE: config.type(false),\r\n EXPORT_CONSTR: config.constr(false),\r\n EXPORT_B64: config.b64(false),\r\n EXPORT_NO_DOWNLOAD: config.noDownload(false),\r\n EXPORT_HEIGHT: config.height(false),\r\n EXPORT_WIDTH: config.width(false),\r\n EXPORT_SCALE: config.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: config.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: config.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: config.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: config.globalOptions(),\r\n EXPORT_THEME_OPTIONS: config.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: config.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: config.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: config.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: config.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: config.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: config.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: config.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: config.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: config.enableServer(false),\r\n SERVER_HOST: config.host(false),\r\n SERVER_PORT: config.port(false),\r\n SERVER_UPLOAD_LIMIT: config.uploadLimit(false),\r\n SERVER_BENCHMARKING: config.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: config.proxyHost(false),\r\n SERVER_PROXY_PORT: config.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: config.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: config.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: config.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: config.window(false),\r\n SERVER_RATE_LIMITING_DELAY: config.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: config.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: config.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: config.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: config.enableSsl(false),\r\n SERVER_SSL_FORCE: config.sslForce(false),\r\n SERVER_SSL_PORT: config.sslPort(false),\r\n SERVER_SSL_CERT_PATH: config.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: config.minWorkers(false),\r\n POOL_MAX_WORKERS: config.maxWorkers(false),\r\n POOL_WORK_LIMIT: config.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: config.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: config.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: config.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: config.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: config.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: config.reaperInterval(false),\r\n POOL_BENCHMARKING: config.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: config.logLevel(false),\r\n LOGGING_FILE: config.logFile(false),\r\n LOGGING_DEST: config.logDest(false),\r\n LOGGING_TO_CONSOLE: config.logToConsole(false),\r\n LOGGING_TO_FILE: config.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: config.enableUi(false),\r\n UI_ROUTE: config.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: config.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: config.listenToProcessExits(false),\r\n OTHER_NO_LOGO: config.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: config.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: config.browserShellMode(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: config.enableDebug(false),\r\n DEBUG_HEADLESS: config.headless(false),\r\n DEBUG_DEVTOOLS: config.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: config.listenToConsole(false),\r\n DEBUG_DUMPIO: config.dumpio(false),\r\n DEBUG_SLOW_MO: config.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: config.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates a provided option using the specific validator from the config\r\n * object.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of an option to validate.\r\n * @param {any} option - The option to validate.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {any} The parsed and validated option value.\r\n */\r\nexport function validateOption(name, option, strictCheck) {\r\n return config[name](strictCheck).parse(option);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate,\r\n validateOption\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport { envs, looseValidate, strictValidate } from './validation.js';\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n // Object for options loaded via the `loadConfig` option\r\n let configOptions = {};\r\n\r\n // Object for options from the CLI\r\n let cliOptions = {};\r\n\r\n // Only for the CLI usage\r\n if (cliArgs.length) {\r\n try {\r\n // Validate options from the custom JSON loaded via the `loadConfig`\r\n configOptions = strictValidate(_loadConfigFile(cliArgs));\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] Custom JSON options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Apply custom options if there are any\r\n if (customOptions && Object.keys(customOptions).length !== 0) {\r\n try {\r\n // Validate custom options provided by the user\r\n customOptions = strictValidate(customOptions);\r\n } catch (error) {\r\n logZodIssues(1, error.issues, '[config] Custom options validation error');\r\n }\r\n }\r\n\r\n // Only for the CLI usage\r\n if (cliArgs.length) {\r\n try {\r\n // Validate options from the CLI\r\n cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n } catch (error) {\r\n logZodIssues(1, error.issues, '[config] CLI options validation error');\r\n }\r\n }\r\n\r\n // Update values of the global options with values from each source possible\r\n _updateGlobalOptions(\r\n defaultConfig,\r\n globalOptions,\r\n configOptions,\r\n cliOptions,\r\n customOptions\r\n );\r\n\r\n // Return updated global options\r\n return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n // Check if options need to be created for a new instance\r\n if (newInstance) {\r\n // Get rid of the old instance options\r\n Object.keys(instanceOptions).forEach((key) => {\r\n delete instanceOptions[key];\r\n });\r\n\r\n // Init the new instance options based on the global options\r\n mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n }\r\n\r\n // Merge additional options to the instance options\r\n mergeOptions(instanceOptions, updateOptions);\r\n\r\n // Return the reference to the instance options object\r\n return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty array.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n .bold.yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[item.envLink];\r\n if (envVal !== undefined && envVal !== null) {\r\n options[name] = envVal;\r\n } else {\r\n options[name] = item.value;\r\n }\r\n } else {\r\n options[name] = _initGlobalOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the config entry of a specific option\r\n const entry = config[key];\r\n\r\n // Gather values for the options from every possible source, if exists\r\n const configVal = configOpt && configOpt[key];\r\n const cliVal = cliOpt && cliOpt[key];\r\n const customVal = customOpt && customOpt[key];\r\n\r\n // If the value not found, need to go deeper\r\n if (typeof entry.value === 'undefined') {\r\n _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n } else {\r\n // If a value from custom JSON options exists, it takes precedence\r\n if (configVal !== undefined && configVal !== null) {\r\n options[key] = configVal;\r\n }\r\n\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[entry.envLink];\r\n if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n options[key] = envVal;\r\n }\r\n\r\n // If a value from CLI options exists, it takes precedence\r\n if (cliVal !== undefined && cliVal !== null) {\r\n options[key] = cliVal;\r\n }\r\n\r\n // If a value from user options exists, it takes precedence\r\n if (customVal !== undefined && customVal !== null) {\r\n options[key] = customVal;\r\n }\r\n }\r\n });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n // Check if the `loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `loadConfig` is present and has a correct value\r\n if (configFileName && customLogicOptions.allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n setGlobalOptions,\r\n updateOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Get the reference to the global options to update to the new version\r\n const options = getOptions();\r\n\r\n // Set to the new version\r\n options.highcharts.version = newVersion;\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: join(__dirname, cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const result = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { getOptions, isAllowedConfig, mergeOptions } from './config.js';\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n deepCopy,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n isObject,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\nimport { strictValidate, validateOption } from './validation.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n try {\r\n // Check if provided options is an object\r\n if (!isObject(exportingOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = mergeOptions(deepCopy(getOptions()), {\r\n export: exportingOptions.export,\r\n customLogic: exportingOptions.customLogic\r\n });\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n try {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent, false);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] The `svg` option validation error'\r\n );\r\n throw error;\r\n }\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n try {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent, false);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] The `instr` option validation error'\r\n );\r\n throw error;\r\n }\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // The last strict validation of options right before exporting process\r\n try {\r\n // Validate final options\r\n options = strictValidate(options);\r\n } catch (error) {\r\n logZodIssues(1, error.issues, '[config] Final options validation error');\r\n }\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled\r\n if (rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n fixConstr,\r\n fixType,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n try {\r\n // Validate options from the body and store parsed structure in the request\r\n request.validatedOptions = looseValidate({\r\n // Set the created ID as a `_requestId` property in the validated options\r\n _requestId: requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${fixType(body.type)}`,\r\n type: fixType(body.type, body.outfile),\r\n constr: fixConstr(body.constr),\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n });\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[config] Request options validation error'\r\n );\r\n\r\n throw new ExportError(\r\n 'The provided options are not correct. Please check if your data is of the correct types.',\r\n 400\r\n );\r\n }\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n let newVersion = request.params.newVersion;\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: serverOptions\r\n });\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n });\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n setGlobalOptions,\r\n mapToNewOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n // Init and update the instance options object\r\n const options = updateOptions(initOptions, true);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n level\r\n }\r\n });\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n });\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n });\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","indexOf","object","passthrough","additionalOptions","adminToken","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","validateOption","name","option","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","Error","customLogicOptions","configIndex","findIndex","arg","i","async","fetch","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","ExportError","constructor","statusCode","super","setStatus","setError","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","_requestId","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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A,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbxG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbxG,KAAM,SAGVA,KAAM,CACJ0C,MAAO,MACP0D,MAAO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"} \ No newline at end of file +{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || '';\r\n logging.file = file || '';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n // Object for options loaded via the `loadConfig` option\r\n let configOptions = {};\r\n\r\n // Object for options from the CLI\r\n let cliOptions = {};\r\n\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Validate options from the custom JSON loaded via the `loadConfig`\r\n configOptions = strictValidate(\r\n _loadConfigFile(cliArgs, globalOptions.customLogic)\r\n );\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options from the `loadConfig` option validation error'\r\n );\r\n }\r\n\r\n try {\r\n // Validate options from the CLI\r\n cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] CLI options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Apply custom options if there are any\r\n if (\r\n customOptions &&\r\n isObject(customOptions) &&\r\n Object.keys(customOptions).length\r\n ) {\r\n try {\r\n // Validate custom options provided by the user\r\n customOptions = strictValidate(customOptions);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Update values of the global options with values from each source possible\r\n _updateGlobalOptions(\r\n defaultConfig,\r\n globalOptions,\r\n configOptions,\r\n cliOptions,\r\n customOptions\r\n );\r\n\r\n // Return updated global options\r\n return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n // Check if options need to be created for a new instance\r\n if (newInstance) {\r\n // Get rid of the old instance options\r\n Object.keys(instanceOptions).forEach((key) => {\r\n delete instanceOptions[key];\r\n });\r\n\r\n // Init the new instance options based on the global options\r\n mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n }\r\n\r\n // Merge additional options to the instance options\r\n mergeOptions(instanceOptions, updateOptions);\r\n\r\n // Return the reference to the instance options object\r\n return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty array.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n .bold.yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[item.envLink];\r\n if (envVal !== undefined && envVal !== null) {\r\n options[name] = envVal;\r\n } else {\r\n options[name] = item.value;\r\n }\r\n } else {\r\n options[name] = _initGlobalOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the config entry of a specific option\r\n const entry = config[key];\r\n\r\n // Gather values for the options from every possible source, if exists\r\n const configVal = configOpt && configOpt[key];\r\n const cliVal = cliOpt && cliOpt[key];\r\n const customVal = customOpt && customOpt[key];\r\n\r\n // If the value not found, need to go deeper\r\n if (typeof entry.value === 'undefined') {\r\n _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n } else {\r\n // If a value from custom JSON options exists, it takes precedence\r\n if (configVal !== undefined && configVal !== null) {\r\n options[key] = configVal;\r\n }\r\n\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[entry.envLink];\r\n if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n options[key] = envVal;\r\n }\r\n\r\n // If a value from CLI options exists, it takes precedence\r\n if (cliVal !== undefined && cliVal !== null) {\r\n options[key] = cliVal;\r\n }\r\n\r\n // If a value from user options exists, it takes precedence\r\n if (customVal !== undefined && customVal !== null) {\r\n options[key] = customVal;\r\n }\r\n }\r\n });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n // Check if the `loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `loadConfig` is present and has a correct value\r\n if (configFileName && customLogicOptions.allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n setGlobalOptions,\r\n updateOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Get the reference to the global options to update to the new version\r\n const options = getOptions();\r\n\r\n // Set to the new version\r\n options.highcharts.version = newVersion;\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: join(__dirname, cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const result = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n getOptions,\r\n isAllowedConfig,\r\n mergeOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n deepCopy,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n isObject,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Validate single export options\r\n options = validateOptions(options);\r\n\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // Validate batch export options\r\n options = validateOptions(options);\r\n\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n try {\r\n // Check if provided options is an object\r\n if (!isObject(exportingOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = mergeOptions(deepCopy(getOptions()), {\r\n export: exportingOptions.export,\r\n customLogic: exportingOptions.customLogic\r\n });\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Validate option\r\n handledResources = validateOption('resources', handledResources);\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled\r\n if (rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n fixConstr,\r\n fixType,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Validate the request options and store parsed structure in the request\r\n request.validatedOptions = validateOptions({\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n });\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n let newVersion = request.params.newVersion;\r\n\r\n // Validate the version\r\n try {\r\n newVersion = validateOption('version', request.params.newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version is incorrect: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // When a correct value found\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: serverOptions\r\n })\r\n );\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n })\r\n );\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n // Init, validate and update the instance options object\r\n const options = updateOptions(validateOptions(initOptions), true);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n level\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","customLogicOptions","configIndex","findIndex","arg","configFileName","i","option","async","fetch","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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ACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbxG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbxG,KAAM,SAGVA,KAAM,CACJ0C,MAAO,MACP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"} \ No newline at end of file From 99de905db570de99146b9ad28cb9fbfc9121822c Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Tue, 21 Jan 2025 02:51:14 +0100 Subject: [PATCH 15/19] Imports corrections. --- dist/index.cjs | 2 +- dist/index.esm.js.map | 2 +- lib/config.js | 4 ++-- lib/index.js | 2 +- lib/pool.js | 2 +- lib/server/middlewares/validation.js | 10 ++-------- lib/server/routes/health.js | 2 +- lib/server/routes/versionChange.js | 2 +- 8 files changed, 10 insertions(+), 16 deletions(-) diff --git a/dist/index.cjs b/dist/index.cjs index 3bc873ff..47997d5a 100644 --- a/dist/index.cjs +++ b/dist/index.cjs @@ -1,2 +1,2 @@ "use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),promises=require("fs/promises"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?e:path.join(__dirname$1,e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),i=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):zod.z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>zod.z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initGlobalOptions(defaultConfig),instanceOptions=deepCopy(globalOptions);function getOptions(e=!0){return e?instanceOptions:globalOptions}function setGlobalOptions(e={},t=[]){let o={},r={};if(t&&Array.isArray(t)&&t.length){try{o=strictValidate(_loadConfigFile(t,globalOptions.customLogic))}catch(e){logZodIssues(1,e.issues,"[validation] Custom options from the `loadConfig` option validation error")}try{r=looseValidate(_pairArgumentValue(nestedProps,t))}catch(e){logZodIssues(1,e.issues,"[validation] CLI options validation error")}}if(e&&isObject(e)&&Object.keys(e).length)try{e=strictValidate(e)}catch(e){logZodIssues(1,e.issues,"[validation] Custom options validation error")}return _updateGlobalOptions(defaultConfig,globalOptions,o,r,e),globalOptions}function updateOptions(e,t=!1){return t&&(Object.keys(instanceOptions).forEach((e=>{delete instanceOptions[e]})),mergeOptions(instanceOptions,deepCopy(globalOptions))),mergeOptions(instanceOptions,e),instanceOptions}function mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initGlobalOptions(e){const t={};for(const[o,r]of Object.entries(e))if(Object.prototype.hasOwnProperty.call(r,"value")){const e=envs[r.envLink];t[o]=null!=e?e:r.value}else t[o]=_initGlobalOptions(r);return t}function _updateGlobalOptions(e,t,o,r,i){Object.keys(e).forEach((n=>{const s=e[n],a=o&&o[n],l=r&&r[n],c=i&&i[n];if(void 0===s.value)_updateGlobalOptions(s,t[n],a,l,c);else{null!=a&&(t[n]=a);const e=envs[s.envLink];s.envLink in envs&&null!=e&&(t[n]=e),null!=l&&(t[n]=l),null!=c&&(t[n]=c)}}))}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _loadConfigFile(e,t){const o=e.findIndex((e=>"loadConfig"===e.replace(/-/g,""))),r=o>-1&&e[o+1];if(r&&t.allowFileResources)try{return isAllowedConfig(fs.readFileSync(getAbsolutePath(r),"utf8"),!1,t.allowCodeExecution)}catch(e){logWithStack(2,e,`[config] Unable to load the configuration from the ${r} file.`)}return{}}function _pairArgumentValue(e,t){const o={};for(let r=0;r{if(n.length-1===s){const n=t[++r];n||log(2,`[config] Missing value for the CLI '--${i}' argument. Using the default value.`),e[o]=n||null}else void 0===e[o]&&(e[o]={});return e[o]}),o)}return o}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),i=path.join(r,"manifest.json"),n=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(fs.readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=getOptions();t.highcharts.version=e,await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await fetch(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,i){let n;const s=r.host,a=r.port;if(s&&a)try{n=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=n?{agent:n,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,i,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,i))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,i=e.cdnUrl||cache.cdnUrl;try{const n={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${i}/${r}/${e}`:`${i}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`))],e.customScripts,t,n),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),n}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=i(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){let i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:path.join(__dirname$1,e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=i?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const i=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${i()}ms.`).setError(n);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${i()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);e=validateOptions(e),await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):fs.writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{e=validateOptions(e);const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):fs.writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.",400);const o=mergeOptions(deepCopy(getOptions()),{export:e.export,customLogic:e.customLogic}),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let i=e,n=!1;if(t&&e.endsWith(".json"))try{i=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else i=isAllowedConfig(e,!1,o),i&&!t&&delete i.files;for(const e in i)r.includes(e)?n||(n=!0):delete i[e];return n?(i.files&&(i.files=i.files.map((e=>e.trim())),(!i.files||i.files.length<=0)&&delete i.files),i=validateOption("resources",i),i):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions=validateOptions({requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}}),o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let i=e.params.newVersion;try{i=validateOption("version",e.params.newVersion)}catch(e){throw new ExportError(`[version] Version is incorrect: ${e.message}`,400).setError(e)}if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions(validateOptions({server:e}));if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=await promises.readFile(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions(validateOptions({server:{rateLimiting:e}}));rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(validateOptions(e),!0);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,setGlobalOptions:setGlobalOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions(validateOptions({logging:{level:e}})).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions(validateOptions({logging:{toConsole:e}})).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions(validateOptions({logging:{dest:e,file:t,toFile:o}}));enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};exports.default=index,exports.initExport=initExport; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || '';\r\n    logging.file = file || '';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n  return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.<string>} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n  // Object for options loaded via the `loadConfig` option\r\n  let configOptions = {};\r\n\r\n  // Object for options from the CLI\r\n  let cliOptions = {};\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Validate options from the custom JSON loaded via the `loadConfig`\r\n      configOptions = strictValidate(\r\n        _loadConfigFile(cliArgs, globalOptions.customLogic)\r\n      );\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options from the `loadConfig` option validation error'\r\n      );\r\n    }\r\n\r\n    try {\r\n      // Validate options from the CLI\r\n      cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] CLI options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Apply custom options if there are any\r\n  if (\r\n    customOptions &&\r\n    isObject(customOptions) &&\r\n    Object.keys(customOptions).length\r\n  ) {\r\n    try {\r\n      // Validate custom options provided by the user\r\n      customOptions = strictValidate(customOptions);\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Update values of the global options with values from each source possible\r\n  _updateGlobalOptions(\r\n    defaultConfig,\r\n    globalOptions,\r\n    configOptions,\r\n    cliOptions,\r\n    customOptions\r\n  );\r\n\r\n  // Return updated global options\r\n  return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n  // Check if options need to be created for a new instance\r\n  if (newInstance) {\r\n    // Get rid of the old instance options\r\n    Object.keys(instanceOptions).forEach((key) => {\r\n      delete instanceOptions[key];\r\n    });\r\n\r\n    // Init the new instance options based on the global options\r\n    mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n  }\r\n\r\n  // Merge additional options to the instance options\r\n  mergeOptions(instanceOptions, updateOptions);\r\n\r\n  // Return the reference to the instance options object\r\n  return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty array.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n        .bold.yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[item.envLink];\r\n      if (envVal !== undefined && envVal !== null) {\r\n        options[name] = envVal;\r\n      } else {\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      options[name] = _initGlobalOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the config entry of a specific option\r\n    const entry = config[key];\r\n\r\n    // Gather values for the options from every possible source, if exists\r\n    const configVal = configOpt && configOpt[key];\r\n    const cliVal = cliOpt && cliOpt[key];\r\n    const customVal = customOpt && customOpt[key];\r\n\r\n    // If the value not found, need to go deeper\r\n    if (typeof entry.value === 'undefined') {\r\n      _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n    } else {\r\n      // If a value from custom JSON options exists, it takes precedence\r\n      if (configVal !== undefined && configVal !== null) {\r\n        options[key] = configVal;\r\n      }\r\n\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[entry.envLink];\r\n      if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n        options[key] = envVal;\r\n      }\r\n\r\n      // If a value from CLI options exists, it takes precedence\r\n      if (cliVal !== undefined && cliVal !== null) {\r\n        options[key] = cliVal;\r\n      }\r\n\r\n      // If a value from user options exists, it takes precedence\r\n      if (customVal !== undefined && customVal !== null) {\r\n        options[key] = customVal;\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n  // Check if the `loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `loadConfig` is present and has a correct value\r\n  if (configFileName && customLogicOptions.allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        customLogicOptions.allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  setGlobalOptions,\r\n  updateOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules.\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = extractVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Get the reference to the global options to update to the new version\r\n  const options = getOptions();\r\n\r\n  // Set to the new version\r\n  options.highcharts.version = newVersion;\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: join(__dirname, cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const result = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n  getOptions,\r\n  isAllowedConfig,\r\n  mergeOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  deepCopy,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  isObject,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Validate single export options\r\n    options = validateOptions(options);\r\n\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // Validate batch export options\r\n    options = validateOptions(options);\r\n\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n  try {\r\n    // Check if provided options is an object\r\n    if (!isObject(exportingOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = mergeOptions(deepCopy(getOptions()), {\r\n      export: exportingOptions.export,\r\n      customLogic: exportingOptions.customLogic\r\n    });\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Validate option\r\n  handledResources = validateOption('resources', handledResources);\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled\r\n    if (rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n  fixConstr,\r\n  fixType,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Validate the request options and store parsed structure in the request\r\n    request.validatedOptions = validateOptions({\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    });\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      log(4, '[ui] Returning UI for the export.');\r\n\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      let newVersion = request.params.newVersion;\r\n\r\n      // Validate the version\r\n      try {\r\n        newVersion = validateOption('version', request.params.newVersion);\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          `[version] Version is incorrect: ${error.message}`,\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // When a correct value found\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        server: serverOptions\r\n      })\r\n    );\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions(\r\n    validateOptions({\r\n      server: {\r\n        rateLimiting: rateLimitingOptions\r\n      }\r\n    })\r\n  );\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n  // Init, validate and update the instance options object\r\n  const options = updateOptions(validateOptions(initOptions), true);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          level\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          toConsole\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          dest,\r\n          file,\r\n          toFile\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","customLogicOptions","configIndex","findIndex","arg","configFileName","i","option","async","fetch","url","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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aAAc,kBAAmB,iBACzC0D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBC,cAAe,CACbvE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eA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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || '';\r\n    logging.file = file || '';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n  return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.<string>} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n  // Object for options loaded via the `loadConfig` option\r\n  let configOptions = {};\r\n\r\n  // Object for options from the CLI\r\n  let cliOptions = {};\r\n\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Validate options from the custom JSON loaded via the `loadConfig`\r\n      configOptions = strictValidate(\r\n        _loadConfigFile(cliArgs, globalOptions.customLogic)\r\n      );\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options from the `loadConfig` option validation error'\r\n      );\r\n    }\r\n\r\n    try {\r\n      // Validate options from the CLI\r\n      cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] CLI options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Apply custom options if there are any\r\n  if (\r\n    customOptions &&\r\n    isObject(customOptions) &&\r\n    Object.keys(customOptions).length\r\n  ) {\r\n    try {\r\n      // Validate custom options provided by the user\r\n      customOptions = strictValidate(customOptions);\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Update values of the global options with values from each source possible\r\n  _updateGlobalOptions(\r\n    defaultConfig,\r\n    globalOptions,\r\n    configOptions,\r\n    cliOptions,\r\n    customOptions\r\n  );\r\n\r\n  // Return updated global options\r\n  return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n  // Check if options need to be created for a new instance\r\n  if (newInstance) {\r\n    // Get rid of the old instance options\r\n    Object.keys(instanceOptions).forEach((key) => {\r\n      delete instanceOptions[key];\r\n    });\r\n\r\n    // Init the new instance options based on the global options\r\n    mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n  }\r\n\r\n  // Merge additional options to the instance options\r\n  mergeOptions(instanceOptions, updateOptions);\r\n\r\n  // Return the reference to the instance options object\r\n  return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty array.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n        .bold.yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[item.envLink];\r\n      if (envVal !== undefined && envVal !== null) {\r\n        options[name] = envVal;\r\n      } else {\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      options[name] = _initGlobalOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the config entry of a specific option\r\n    const entry = config[key];\r\n\r\n    // Gather values for the options from every possible source, if exists\r\n    const configVal = configOpt && configOpt[key];\r\n    const cliVal = cliOpt && cliOpt[key];\r\n    const customVal = customOpt && customOpt[key];\r\n\r\n    // If the value not found, need to go deeper\r\n    if (typeof entry.value === 'undefined') {\r\n      _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n    } else {\r\n      // If a value from custom JSON options exists, it takes precedence\r\n      if (configVal !== undefined && configVal !== null) {\r\n        options[key] = configVal;\r\n      }\r\n\r\n      // If a value from environment variables exists, it takes precedence\r\n      const envVal = envs[entry.envLink];\r\n      if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n        options[key] = envVal;\r\n      }\r\n\r\n      // If a value from CLI options exists, it takes precedence\r\n      if (cliVal !== undefined && cliVal !== null) {\r\n        options[key] = cliVal;\r\n      }\r\n\r\n      // If a value from user options exists, it takes precedence\r\n      if (customVal !== undefined && customVal !== null) {\r\n        options[key] = customVal;\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n  // Check if the `loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `loadConfig` is present and has a correct value\r\n  if (configFileName && customLogicOptions.allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        customLogicOptions.allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  setGlobalOptions,\r\n  updateOptions,\r\n  mergeOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules.\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = extractVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Get the reference to the global options to update to the new version\r\n  const options = getOptions();\r\n\r\n  // Set to the new version\r\n  options.highcharts.version = newVersion;\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: join(__dirname, cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const result = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n  getOptions,\r\n  isAllowedConfig,\r\n  mergeOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  deepCopy,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  isObject,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Validate single export options\r\n    options = validateOptions(options);\r\n\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // Validate batch export options\r\n    options = validateOptions(options);\r\n\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n  try {\r\n    // Check if provided options is an object\r\n    if (!isObject(exportingOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = mergeOptions(deepCopy(getOptions()), {\r\n      export: exportingOptions.export,\r\n      customLogic: exportingOptions.customLogic\r\n    });\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Validate option\r\n  handledResources = validateOption('resources', handledResources);\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled\r\n    if (rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Validate the request options and store parsed structure in the request\r\n    request.validatedOptions = validateOptions({\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    });\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      log(4, '[ui] Returning UI for the export.');\r\n\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      let newVersion = request.params.newVersion;\r\n\r\n      // Validate the version\r\n      try {\r\n        newVersion = validateOption('version', request.params.newVersion);\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          `[version] Version is incorrect: ${error.message}`,\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // When a correct value found\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        server: serverOptions\r\n      })\r\n    );\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = await readFile(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions(\r\n    validateOptions({\r\n      server: {\r\n        rateLimiting: rateLimitingOptions\r\n      }\r\n    })\r\n  );\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n  updateOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n  // Init, validate and update the instance options object\r\n  const options = updateOptions(validateOptions(initOptions), true);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  setGlobalOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          level\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          toConsole\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          dest,\r\n          file,\r\n          toFile\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","customLogicOptions","configIndex","findIndex","arg","configFileName","i","option","async","fetch","url","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"wnBA2BO,MAAMA,YAAYC,IAAaA,cAAC,IAAIC,IAAI,OAAQ,oBAAAC,SAAAC,QAAA,OAAAC,cAAAC,YAAAC,KAAAC,wBAAA,WAAAA,uBAAAC,QAAAC,eAAAF,uBAAAG,KAAA,IAAAT,IAAA,YAAAC,SAAAS,SAAAL,OA+BhD,SAASM,SAASC,GAEvB,GAAe,OAAXA,GAAqC,iBAAXA,EAC5B,OAAOA,EAIT,MAAMC,EAAaC,MAAMC,QAAQH,GAAU,GAAK,GAGhD,IAAK,MAAMI,KAAOJ,EACZK,OAAOC,UAAUC,eAAeC,KAAKR,EAAQI,KAC/CH,EAAWG,GAAOL,SAASC,EAAOI,KAKtC,OAAOH,CACT,CA2DO,SAASQ,UAAUC,GACxB,IAEE,MAAMC,EAAc,GAAGD,EAAOE,cAAcC,QAAQ,QAAS,WAQ7D,MALoB,UAAhBF,GACFA,EAAYC,cAIP,CAAC,QAAS,aAAc,WAAY,cAAcE,SACvDH,GAEEA,EACA,OACR,CAAI,MAEA,MAAO,OACR,CACH,CAYO,SAASI,WAAWC,EAAMC,GAO/B,MAAO,GALUC,gBAAgBD,GAAW,SACzCE,MAAM,KACNC,WAGmBJ,GACxB,CAaO,SAASK,QAAQL,EAAMC,EAAU,MAEtC,MAAMK,EAAY,CAChB,YAAa,MACb,aAAc,OACd,kBAAmB,MACnB,gBAAiB,OAIbC,EAAUlB,OAAOmB,OAAOF,GAG9B,GAAIL,EAAS,CACX,MAAMQ,EAAUR,EAAQE,MAAM,KAAKO,MAGnB,QAAZD,EACFT,EAAO,OACEO,EAAQT,SAASW,IAAYT,IAASS,IAC/CT,EAAOS,EAEV,CAGD,OAAOH,EAAUN,IAASO,EAAQI,MAAMC,GAAMA,IAAMZ,KAAS,KAC/D,CAYO,SAASE,gBAAgBW,GAC9B,OAAOC,KAAAA,WAAWD,GAAQA,EAAOE,KAAAA,KAAK7C,YAAW2C,EACnD,CAYO,SAASG,UAAUC,EAAOjB,GAE/B,MAAa,QAATA,GAA0B,OAARA,EACbkB,OAAOC,KAAKF,EAAO,QAAQG,SAAS,UAItCH,CACT,CAOO,SAASI,aAEd,OAAO,IAAIC,MAAOF,WAAWjB,MAAM,KAAK,GAAGoB,MAC7C,CAOO,SAASC,iBACd,OAAO,IAAIF,MAAOG,SACpB,CAWO,SAASC,SAASC,GACvB,MAAgD,oBAAzCtC,OAAOC,UAAU8B,SAAS5B,KAAKmC,EACxC,CAWO,SAASC,cAAcD,GAC5B,MACkB,iBAATA,IACNzC,MAAMC,QAAQwC,IACN,OAATA,GAC6B,IAA7BtC,OAAOwC,KAAKF,GAAMG,MAEtB,CAWO,SAASC,uBAAuBJ,GASrC,MARsB,CACpB,mDACA,uEACA,wEACA,uFACA,qEAGmBK,MAAMC,GAAYA,EAAQC,KAAKP,IACtD,CASO,SAASQ,cACd,MAAMC,EAAQC,QAAQC,OAAOC,SAC7B,MAAO,IAAMC,OAAOH,QAAQC,OAAOC,SAAWH,GAAS,GACzD,CAYO,SAASK,YAAYC,EAAOC,EAAY,GAC7C,MAAMC,EAAaC,KAAKC,IAAI,GAAIH,GAAa,GAC7C,OAAOE,KAAKE,OAAOL,EAAQE,GAAcA,CAC3C,CA6BO,SAASI,WAAWC,EAAYC,EAAoBC,GAAa,GACtE,GAAIF,GAAoC,iBAAfA,EAGvB,OAFAA,EAAaA,EAAW1B,QAET6B,SAAS,OAEfF,EACHF,WACEK,GAAAA,aAAanD,gBAAgB+C,GAAa,QAC1CC,EACAC,GAEF,MAEHA,IACAF,EAAWK,WAAW,eACrBL,EAAWK,WAAW,gBACtBL,EAAWK,WAAW,SACtBL,EAAWK,WAAW,UAGjB,IAAIL,OAINA,EAAWpD,QAAQ,KAAM,GAEpC,CCvXA,MAAM0D,OAAS,CAAC,MAAO,SAAU,OAAQ,OAAQ,SAG3CC,QAAU,CAEdC,WAAW,EACXC,QAAQ,EACRC,aAAa,EAEbC,UAAW,GAEXC,WAAY,CACV,CACEC,MAAO,QACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,UACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,SACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,UACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,YACPC,MAAOR,OAAO,MAkBb,SAASS,OAAOC,GACrB,MAAOC,KAAaC,GAASF,GAGvBJ,WAAEA,EAAUO,MAAEA,GAAUZ,QAG9B,GACe,IAAbU,IACc,IAAbA,GAAkBA,EAAWE,GAASA,EAAQP,EAAW/B,QAE1D,OAIF,MAAMuC,EAAS,GAAGhD,iBAAiBwC,EAAWK,EAAW,GAAGJ,WAGxDN,QAAQE,QACVY,WAAWH,EAAOE,GAIhBb,QAAQC,WACVc,QAAQP,IAAIQ,WACVC,EACA,CAACJ,EAAOjD,WAAWoC,QAAQK,WAAWK,EAAW,GAAGH,QAAQW,OAAOP,GAGzE,CAgBO,SAASQ,aAAaT,EAAUU,EAAOC,GAE5C,MAAMC,EAAcD,GAAkBD,GAASA,EAAMG,SAAY,IAG3DX,MAAEA,EAAKP,WAAEA,GAAeL,QAG9B,GAAiB,IAAbU,GAAkBA,EAAWE,GAASA,EAAQP,EAAW/B,OAC3D,OAIF,MAAMuC,EAAS,GAAGhD,iBAAiBwC,EAAWK,EAAW,GAAGJ,WAGtDkB,EAAeJ,GAASA,EAAMK,MAG9Bd,EAAQ,CAACW,GACXE,GACFb,EAAMe,KAAK,KAAMF,GAIfxB,QAAQE,QACVY,WAAWH,EAAOE,GAIhBb,QAAQC,WACVc,QAAQP,IAAIQ,WACVC,EACA,CAACJ,EAAOjD,WAAWoC,QAAQK,WAAWK,EAAW,GAAGH,QAAQW,OAAO,CACjEP,EAAM/D,QAAQmD,OAAOW,EAAW,OAC7BC,IAIX,CAaO,SAASgB,aAAajB,EAAUkB,EAAQP,GAC7CF,aACET,EACA,KACA,CACE,GAAGW,GAAiB,0EAChBO,GAAU,IAAIC,KAAKC,GAAU,KAAKA,EAAMP,aAC5ChE,KAAK,MAEX,CAUO,SAASwE,YAAYC,GAE1B,MAAMpB,MAAEA,EAAKqB,KAAEA,EAAIC,KAAEA,EAAIjC,UAAEA,EAASC,OAAEA,GAAW8B,EAGjDhC,QAAQG,aAAc,EACtBH,QAAQI,UAAY,GAGpB+B,YAAYvB,GAGZwB,qBAAqBnC,GAGrBoC,kBAAkBJ,EAAMC,EAAMhC,EAChC,CAUO,SAASiC,YAAYvB,GAExB5B,OAAOsD,UAAU1B,IACjBA,GAAS,GACTA,GAASZ,QAAQK,WAAW/B,SAG5B0B,QAAQY,MAAQA,EAEpB,CASO,SAASwB,qBAAqBnC,GAEnCD,QAAQC,YAAcA,CACxB,CAaO,SAASoC,kBAAkBJ,EAAMC,EAAMhC,GAE5CF,QAAQE,SAAWA,EAGfF,QAAQE,SACVF,QAAQiC,KAAOA,GAAQ,GACvBjC,QAAQkC,KAAOA,GAAQ,GAE3B,CAYA,SAASpB,WAAWH,EAAOE,GACpBb,QAAQG,eAEVoC,cAAW7F,gBAAgBsD,QAAQiC,QAClCO,GAAAA,UAAU9F,gBAAgBsD,QAAQiC,OAGpCjC,QAAQI,UAAY1D,gBAAgBa,KAAIA,KAACyC,QAAQiC,KAAMjC,QAAQkC,OAI/DlC,QAAQG,aAAc,GAIxBsC,GAAUA,WACRzC,QAAQI,UACR,CAACS,GAAQK,OAAOP,GAAOpD,KAAK,KAAO,MAClC6D,IACKA,GAASpB,QAAQE,QAAUF,QAAQG,cACrCH,QAAQE,QAAS,EACjBF,QAAQG,aAAc,EACtBgB,aAAa,EAAGC,EAAO,yCACxB,GAGP,CCvQO,MAAMsB,cAAgB,CAC3BC,UAAW,CACTlC,KAAM,CACJvB,MAAO,CACL,mCACA,kBACA,0CACA,2BACA,kCACA,kCACA,wCACA,2CACA,qBACA,4BACA,2CACA,uDACA,6BACA,yBACA,0BACA,+BACA,uBACA,uFACA,yBACA,oCACA,oBACA,0BACA,8CACA,2BACA,0BACA,6BACA,mCACA,wCACA,mCACA,2BACA,kCACA,uBACA,iBACA,yBACA,8BACA,oBACA,2BACA,eACA,6BACA,iBACA,aACA,eACA,sBACA,cACA,yBACA,oBACA,uBAEF0D,MAAO,CAAC,YACRC,QAAS,iBACTC,QAAS,gBACTC,YAAa,+BACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBC,WAAY,CACVC,QAAS,CACPjE,MAAO,SACP0D,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbxG,KAAM,SAGV4G,OAAQ,CACNlE,MAAO,8BACP0D,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbxG,KAAM,SAGV6G,WAAY,CACVnE,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbxG,KAAM,WAGV8G,UAAW,CACTpE,MAAO,SACP0D,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbxG,KAAM,SAGV+G,YAAa,CACXrE,MAAO,CAAC,aAAc,kBAAmB,iBACzC0D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBC,cAAe,CACbvE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbxG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbxG,KAAM,SAGVA,KAAM,CACJ0C,MAAO,MACP0D,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,oDACbC,cAAe,CACbxG,KAAM,SACN0H,KAAM,eACNC,QAAS,CAAC,MAAO,OAAQ,MAAO,SAGpCjI,OAAQ,CACNgD,MAAO,QACP0D,MAAO,CAAC,UACRC,QAAS,gBACTE,YACE,uEACFC,cAAe,CACbxG,KAAM,SACN0H,KAAM,iBACNC,QAAS,CAAC,QAAS,aAAc,WAAY,gBAGjDC,IAAK,CACHlF,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,aACTE,YACE,oFACFC,cAAe,CACbxG,KAAM,WAGV6H,WAAY,CACVnF,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,qBACTE,YACE,0EACFC,cAAe,CACbxG,KAAM,WAGV8H,OAAQ,CACNpF,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YAAa,yDACbC,cAAe,CACbxG,KAAM,WAGV+H,MAAO,CACLrF,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YAAa,wDACbC,cAAe,CACbxG,KAAM,WAGVgI,MAAO,CACLtF,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gFACFC,cAAe,CACbxG,KAAM,WAGViI,cAAe,CACbvF,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,kDACbC,cAAe,CACbxG,KAAM,WAGVkI,aAAc,CACZxF,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,iDACbC,cAAe,CACbxG,KAAM,WAGVmI,aAAc,CACZzF,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,uBACTE,YACE,yEACFC,cAAe,CACbxG,KAAM,SACNoI,IAAK,GACLC,IAAK,IAGTC,cAAe,CACb5F,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,wBACTE,YACE,mFACFC,cAAe,CACbxG,KAAM,SAGVuI,aAAc,CACZ7F,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,uBACTE,YACE,kFACFC,cAAe,CACbxG,KAAM,SAGVwI,qBAAsB,CACpB9F,MAAO,KACP0D,MAAO,CAAC,UACRC,QAAS,+BACTE,YAAa,6CACbC,cAAe,CACbxG,KAAM,YAIZyI,YAAa,CACXC,mBAAoB,CAClBhG,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,oCACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,WAGVkD,mBAAoB,CAClBR,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,oCACTE,YACE,kFACFC,cAAe,CACbxG,KAAM,WAGViD,WAAY,CACVP,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,2BACTE,YACE,uHACFC,cAAe,CACbxG,KAAM,SAGV2I,SAAU,CACRjG,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,wBACTE,YACE,kFACFC,cAAe,CACbxG,KAAM,SAGV4I,UAAW,CACTlG,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,yBACTE,YACE,sGACFC,cAAe,CACbxG,KAAM,SAGV6I,WAAY,CACVnG,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,2BACTyC,WAAY,WACZvC,YAAa,+CACbC,cAAe,CACbxG,KAAM,SAGV+I,aAAc,CACZrG,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,6BACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,UAIZgJ,OAAQ,CACNC,OAAQ,CACNvG,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,gBACTC,QAAS,eACTC,YAAa,8BACbC,cAAe,CACbxG,KAAM,WAGVkJ,KAAM,CACJxG,MAAO,UACP0D,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,yBACbC,cAAe,CACbxG,KAAM,SAGVmJ,KAAM,CACJzG,MAAO,KACP0D,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,6BACbC,cAAe,CACbxG,KAAM,WAGVoJ,YAAa,CACX1G,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,sBACTE,YAAa,kCACbC,cAAe,CACbxG,KAAM,WAGVqJ,aAAc,CACZ3G,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,sBACTC,QAAS,qBACTC,YACE,0EACFC,cAAe,CACbxG,KAAM,WAGVsJ,MAAO,CACLJ,KAAM,CACJxG,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,oBACTC,QAAS,YACTC,YAAa,0CACbC,cAAe,CACbxG,KAAM,SAGVmJ,KAAM,CACJzG,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,oBACTC,QAAS,YACTC,YAAa,0CACbC,cAAe,CACbxG,KAAM,WAGVuJ,QAAS,CACP7G,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,uBACTC,QAAS,eACTC,YACE,8DACFC,cAAe,CACbxG,KAAM,YAIZwJ,aAAc,CACZP,OAAQ,CACNvG,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,8BACTC,QAAS,qBACTC,YAAa,kDACbC,cAAe,CACbxG,KAAM,WAGVyJ,YAAa,CACX/G,MAAO,GACP0D,MAAO,CAAC,UACRC,QAAS,oCACTyC,WAAY,YACZvC,YAAa,gDACbC,cAAe,CACbxG,KAAM,WAGV0J,OAAQ,CACNhH,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,8BACTE,YAAa,2CACbC,cAAe,CACbxG,KAAM,WAGV2J,MAAO,CACLjH,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,6BACTE,YACE,uEACFC,cAAe,CACbxG,KAAM,WAGV4J,WAAY,CACVlH,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,mCACTE,YAAa,sDACbC,cAAe,CACbxG,KAAM,WAGV6J,QAAS,CACPnH,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gCACTE,YAAa,wDACbC,cAAe,CACbxG,KAAM,SAGV8J,UAAW,CACTpH,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,kCACTE,YAAa,wDACbC,cAAe,CACbxG,KAAM,UAIZ+J,IAAK,CACHd,OAAQ,CACNvG,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,oBACTC,QAAS,YACTC,YAAa,mCACbC,cAAe,CACbxG,KAAM,WAGVgK,MAAO,CACLtH,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,mBACTC,QAAS,WACTwC,WAAY,UACZvC,YAAa,gDACbC,cAAe,CACbxG,KAAM,WAGVmJ,KAAM,CACJzG,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,kBACTC,QAAS,UACTC,YAAa,0BACbC,cAAe,CACbxG,KAAM,WAGViK,SAAU,CACRvH,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,uBACTC,QAAS,cACTwC,WAAY,UACZvC,YAAa,uCACbC,cAAe,CACbxG,KAAM,WAKdkK,KAAM,CACJC,WAAY,CACVzH,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,mBACTE,YAAa,sDACbC,cAAe,CACbxG,KAAM,WAGVoK,WAAY,CACV1H,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,mBACTyC,WAAY,UACZvC,YAAa,0CACbC,cAAe,CACbxG,KAAM,WAGVqK,UAAW,CACT3H,MAAO,GACP0D,MAAO,CAAC,UACRC,QAAS,kBACTE,YAAa,wDACbC,cAAe,CACbxG,KAAM,WAGVsK,eAAgB,CACd5H,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,WAGVuK,cAAe,CACb7H,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,sBACTE,YAAa,kDACbC,cAAe,CACbxG,KAAM,WAGVwK,eAAgB,CACd9H,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,oDACbC,cAAe,CACbxG,KAAM,WAGVyK,YAAa,CACX/H,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,oBACTE,YAAa,wDACbC,cAAe,CACbxG,KAAM,WAGV0K,oBAAqB,CACnBhI,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,6BACTE,YACE,wEACFC,cAAe,CACbxG,KAAM,WAGV2K,eAAgB,CACdjI,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,uBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,WAGVqJ,aAAc,CACZ3G,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,oBACTC,QAAS,mBACTC,YAAa,6CACbC,cAAe,CACbxG,KAAM,YAIZwD,QAAS,CACPY,MAAO,CACL1B,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,gBACTC,QAAS,WACTC,YAAa,0BACbC,cAAe,CACbxG,KAAM,SACN+C,MAAO,EACPqF,IAAK,EACLC,IAAK,IAGT3C,KAAM,CACJhD,MAAO,+BACP0D,MAAO,CAAC,UACRC,QAAS,eACTC,QAAS,UACTC,YACE,8DACFC,cAAe,CACbxG,KAAM,SAGVyF,KAAM,CACJ/C,MAAO,MACP0D,MAAO,CAAC,UACRC,QAAS,eACTC,QAAS,UACTC,YAAa,0DACbC,cAAe,CACbxG,KAAM,SAGVyD,UAAW,CACTf,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,qBACTC,QAAS,eACTC,YAAa,sCACbC,cAAe,CACbxG,KAAM,WAGV0D,OAAQ,CACNhB,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,kBACTC,QAAS,YACTC,YAAa,wCACbC,cAAe,CACbxG,KAAM,YAIZ4K,GAAI,CACF3B,OAAQ,CACNvG,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,YACTC,QAAS,WACTC,YAAa,mDACbC,cAAe,CACbxG,KAAM,WAGV6K,MAAO,CACLnI,MAAO,IACP0D,MAAO,CAAC,UACRC,QAAS,WACTC,QAAS,UACTC,YAAa,gCACbC,cAAe,CACbxG,KAAM,UAIZ8K,MAAO,CACLC,QAAS,CACPrI,MAAO,aACP0D,MAAO,CAAC,UACRC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVgL,qBAAsB,CACpBtI,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,gCACTE,YAAa,iDACbC,cAAe,CACbxG,KAAM,WAGViL,OAAQ,CACNvI,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,gBACTE,YAAa,+CACbC,cAAe,CACbxG,KAAM,WAGVkL,cAAe,CACbxI,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,wBACTE,YAAa,oDACbC,cAAe,CACbxG,KAAM,WAGVmL,iBAAkB,CAChBzI,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,2BACTE,YAAa,yDACbC,cAAe,CACbxG,KAAM,WAGVoL,WAAY,CACV1I,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,mBACTE,YAAa,uDACbC,cAAe,CACbxG,KAAM,YAIZqL,MAAO,CACLpC,OAAQ,CACNvG,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,eACTC,QAAS,cACTC,YAAa,4DACbC,cAAe,CACbxG,KAAM,WAGVsL,SAAU,CACR5I,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,iBACTE,YACE,6EACFC,cAAe,CACbxG,KAAM,WAGVuL,SAAU,CACR7I,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,iBACTE,YAAa,+CACbC,cAAe,CACbxG,KAAM,WAGVwL,gBAAiB,CACf9I,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,0BACTE,YACE,qEACFC,cAAe,CACbxG,KAAM,WAGVyL,OAAQ,CACN/I,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,eACTE,YACE,kFACFC,cAAe,CACbxG,KAAM,WAGV0L,OAAQ,CACNhJ,MAAO,EACP0D,MAAO,CAAC,UACRC,QAAS,gBACTE,YAAa,4DACbC,cAAe,CACbxG,KAAM,WAGV2L,cAAe,CACbjJ,MAAO,KACP0D,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,0BACbC,cAAe,CACbxG,KAAM,aAOD4L,YAAcC,mBAAmB3F,eAGjC4F,cAAgBC,qBAAqB7F,eAoBlD,SAAS2F,mBAAmBG,EAAQJ,EAAc,CAAA,EAAIK,EAAY,IAqBhE,OApBA5M,OAAOwC,KAAKmK,GAAQE,SAAS9M,IAE3B,MAAM+M,EAAQH,EAAO5M,QAGM,IAAhB+M,EAAMzJ,MAEfmJ,mBAAmBM,EAAOP,EAAa,GAAGK,KAAa7M,MAGvDwM,EAAYO,EAAM7F,SAAWlH,GAAO,GAAG6M,KAAa7M,IAAMgN,UAAU,QAG3C3H,IAArB0H,EAAMrD,aACR8C,EAAYO,EAAMrD,YAAc,GAAGmD,KAAa7M,IAAMgN,UAAU,IAEnE,IAIIR,CACT,CAiBA,SAASG,qBAAqBC,EAAQF,EAAgB,IAkBpD,OAjBAzM,OAAOwC,KAAKmK,GAAQE,SAAS9M,IAE3B,MAAM+M,EAAQH,EAAO5M,QAGM,IAAhB+M,EAAM/F,MAEf2F,qBAAqBI,EAAOL,GAGxBK,EAAM/F,MAAMtG,SAAS,WACvBgM,EAAc5G,KAAK9F,EAEtB,IAII0M,CACT,CC5hCAO,OAAOL,SAGP,MAAMjF,YAAEA,YAAWE,cAAEA,cAAaC,iBAAEA,kBAClChB,cAAcQ,WAGhB4F,IAAAA,EAAEC,YAAYC,iBAWd,MAAMC,EAAI,CAwBRC,QAAQC,GACCA,EACHL,IAAAA,EAAEI,UACFJ,IAACA,EACEM,MAAM,CACLN,IAACA,EACEO,KAAK,CAAC,OAAQ,IAAK,QAAS,IAAK,YAAa,OAAQ,KACtDC,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAEhC,KADU,SAAVA,GAA8B,MAAVA,IAG5B4J,IAAAA,EAAEI,YAEHK,WAuBTC,OAAOL,GACEA,EACHL,IAACA,EACEU,SACAzL,OACA0L,QACEvK,IAAW,CAAC,QAAS,YAAa,OAAQ,IAAI5C,SAAS4C,IACxD,CACEwK,OAAQ,CACNC,aAAc,2CAItBb,IAACA,EACEU,SACAzL,OACAuL,WAAWpK,GACT,CAAC,QAAS,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAEvDqK,WA0BTF,KAAI,CAACrM,EAAQmM,IACJA,EACHL,IAAAA,EAAEO,KAAK,IAAIrM,IACX8L,IAACA,EACEO,KAAK,IAAIrM,EAAQ,YAAa,OAAQ,KACtCsM,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAE9CqK,WA4BT,WAAAK,CAAYC,EAAgB5G,EAAWkG,GACrC,MAAMW,EAAchB,IAAAA,EAAEU,SAASzL,OAAOgM,QAChCC,EAAelB,IAACA,EACnBU,SACAzL,OACAuL,WAAWpK,IACNA,EAAMY,WAAW,OACnBZ,EAAQA,EAAM+K,MAAM,IAElB/K,EAAMU,SAAS,OACjBV,EAAQA,EAAM+K,MAAM,GAAK,IAEpB/K,EAAMvC,MAAMsG,MAGjBiH,EAAqBhL,GACzBA,EAAM2C,KAAK3C,GAAUA,EAAMnB,SAAQoM,OAAON,GAE5C,OAAOV,EACHW,EAAYR,UAAUY,GACtBpB,IAACA,EACEM,MAAM,CAACY,EAAcF,IACrBR,UAAUY,GACVZ,WAAWpK,GAAWA,EAAMZ,OAASY,EAAQ,OAC7CqK,UACR,EAwBDa,YAAYjB,GACHA,EACHL,MAAEuB,SAASC,WACXxB,IAACA,EACEM,MAAM,CACLN,IAACA,EACEU,SACAzL,OACA0L,QACEvK,IACGqL,MAAMvL,OAAOE,KAAWF,OAAOE,GAAS,GAC1C,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aAAc,4CAInBL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAEhC,KADAF,OAAOE,KAGf4J,MAAEuB,SAASC,aAEZf,WA0BTiB,eAAerB,GACNA,EACHL,MAAEuB,SAASI,cACX3B,IAACA,EACEM,MAAM,CACLN,IAACA,EACEU,SACAzL,OACA0L,QACEvK,IACGqL,MAAMvL,OAAOE,KAAWF,OAAOE,IAAU,GAC3C,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aAAc,gDAInBL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAEhC,KADAF,OAAOE,KAGf4J,MAAEuB,SAASI,gBAEZlB,WA8BTzJ,WAAU,CAAC4K,EAAUvB,IACZA,EACHL,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GAAUwL,EAASlM,MAAMqC,GAAW3B,EAAMY,WAAWe,MACtD,CACE6I,OAAQ,CACNC,aAAc,+CAA+Ce,EAASnN,KAAK,WAInFuL,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACCwL,EAASlM,MAAMqC,GAAW3B,EAAMY,WAAWe,MAC3C,CAAC,YAAa,OAAQ,IAAIvE,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aAAc,+CAA+Ce,EAASnN,KAAK,WAIhF+L,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAE9CqK,WAgBToB,YAAW,IACF7B,IAACA,EACLM,MAAM,CACLN,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACEA,EAAMY,WAAW,MAAQZ,EAAMU,SAAS,MACzC,CAAC,YAAa,OAAQ,IAAItD,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aACE,uEAIPL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAEjD4J,IAAAA,EAAE8B,OAAO,IAAIC,gBAEdtB,WAiBLuB,kBAAiB,IACRhC,IAACA,EACLM,MAAM,CACLN,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACEA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACpCV,EAAMY,WAAW,MAAQZ,EAAMU,SAAS,MACzC,CAAC,YAAa,OAAQ,IAAItD,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aACE,4FAIPL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAEjD4J,IAAAA,EAAE8B,OAAO,IAAIC,gBAEdtB,YAaMwB,WAAa,CAexBtK,KAAK0I,GACIF,EAAEW,aACN1K,IAAW,CAAC,QAAS,YAAa,OAAQ,IAAI5C,SAAS4C,IACxD,IACAiK,GA2BJhG,QAAQgG,GACCA,EACHL,IAACA,EACEU,SACAzL,OACA0L,QAAQvK,GAAU,qCAAqCR,KAAKQ,IAAQ,CACnEwK,OAAQ,CACNC,aACE,0EAGRb,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACC,qCAAqCR,KAAKQ,IAC1C,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aACE,0EAIPL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAE9CqK,WAiBTnG,OAAO+F,GACEF,EAAEnJ,WAAW,CAAC,UAAW,YAAaqJ,GAiB/C9F,WAAW8F,GACFF,EAAEC,QAAQC,GAiBnB7F,UAAU6F,GACDF,EAAEO,OAAOL,GAiBlB6B,WAAW7B,GACFF,EAAEO,OAAOL,GAiBlB5F,YAAY4F,GACHF,EAAEW,aACN1K,GAAUqE,YAAYrE,MAAM5C,SAAS4C,IACtC,IACAiK,GAkBJ1F,cAAc0F,GACLF,EAAEW,aACN1K,GAAUuE,cAAcvE,MAAM5C,SAAS4C,IACxC,IACAiK,GAkBJzF,iBAAiByF,GACRF,EAAEW,aACN1K,GAAUwE,iBAAiBxE,MAAM5C,SAAS4C,IAC3C,IACAiK,GAkBJxF,cAAcwF,GACLF,EAAEW,aACN1K,GAAUA,EAAMY,WAAW,aAAeZ,EAAMY,WAAW,YAC5D,IACAqJ,GA2BJtF,OAAOsF,GACEA,EACHL,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACEA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACpCV,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,SACvC,CACE8J,OAAQ,CACNC,aACE,6DAIPJ,WACHT,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACEA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACpCV,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,SACrC,CAAC,YAAa,OAAQ,IAAItD,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aACE,6DAIPL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAE9CqK,WAaTzF,MAAK,IACImF,EAAE0B,cAaX5G,QAAO,IACEkF,EAAE0B,cAiBX3G,IAAG,IACM8E,IAACA,EACLU,SACAzL,OACA0L,QACEvK,GACCA,EAAM+L,QAAQ,SAAW,GACzB/L,EAAM+L,QAAQ,UAAY,GAC1B,CAAC,QAAS,YAAa,OAAQ,IAAI3O,SAAS4C,IAC9C,CACEwK,OAAQ,CACNC,aACE,gEAIPL,WAAWpK,GACT,CAAC,QAAS,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAEvDqK,WA0BL9M,QAAQ0M,GACCA,EACHL,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACEA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACpCV,EAAMZ,QAAU,IACdY,EAAMU,SAAS,SACdV,EAAMU,SAAS,SACfV,EAAMU,SAAS,SACfV,EAAMU,SAAS,UACrB,CACE8J,OAAQ,CACNC,aACE,gFAIPJ,WACHT,IAACA,EACEU,SACAzL,OACA0L,QACEvK,GACEA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACpCV,EAAMZ,QAAU,IACdY,EAAMU,SAAS,SACdV,EAAMU,SAAS,SACfV,EAAMU,SAAS,SACfV,EAAMU,SAAS,UACnB,CAAC,YAAa,OAAQ,IAAItD,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aACE,gFAIPL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAE9CqK,WAiBT/M,KAAK2M,GACIF,EAAEI,KAAK,CAAC,OAAQ,MAAO,MAAO,MAAO,OAAQF,GAiBtDjN,OAAOiN,GACEF,EAAEI,KACP,CAAC,QAAS,aAAc,WAAY,cACpCF,GAiBJ/E,IAAI+E,GACKF,EAAEC,QAAQC,GAiBnB9E,WAAW8E,GACFF,EAAEC,QAAQC,GAiBnB1E,cAAc0E,GACLF,EAAEmB,YAAYjB,GAiBvBzE,aAAayE,GACJF,EAAEmB,YAAYjB,GAwBvBxE,aAAawE,GACJA,EACHL,IAACA,EAACuB,SAASa,IAAI,IAAKC,IAAI,GACxBrC,IAACA,EACEM,MAAM,CACLN,IAACA,EACEU,SACAzL,OACA0L,QACEvK,IACGqL,MAAMvL,OAAOE,MACH,IAAVA,IACCA,EAAMY,WAAW,MAClBd,OAAOE,IAAU,IACjBF,OAAOE,IAAU,GACnB,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aAAc,kDAInBL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAEhC,KADAF,OAAOE,KAGf4J,IAACA,EAACuB,SAASa,IAAI,IAAKC,IAAI,KAEzB5B,WAkBT,MAAAjF,CAAO6E,GACL,OAAOiC,KAAK3G,cAAc0E,GAAaI,UACxC,EAiBD,KAAAhF,CAAM4E,GACJ,OAAOiC,KAAK1G,aAAayE,GAAaI,UACvC,EAiBD,KAAA/E,CAAM2E,GACJ,OAAOiC,KAAKzG,aAAawE,GAAaI,UACvC,EAaDzE,cAAa,IACJmE,EAAE6B,oBAcX/F,aAAY,IACHkE,EAAE6B,oBAiBX7G,MAAMkF,GACGF,EAAEO,OAAOL,GAkBlBnE,qBAAqBmE,GACZF,EAAEuB,eAAerB,GAiB1BjE,mBAAmBiE,GACVF,EAAEC,QAAQC,GAiBnBzJ,mBAAmByJ,GACVF,EAAEC,QAAQC,GAiBnB1J,WAAW0J,GACFF,EAAEO,OAAOL,GAiBlBhE,SAASgE,GACAF,EAAEO,OAAOL,GA4BlB,SAAA/D,CAAU+D,GACR,MAAMkC,EAAevC,IAACA,EACnB8B,OAAO,CACNU,GAAIrC,EAAEO,QAAO,GACb+B,IAAKtC,EAAEO,QAAO,GACdgC,MAAOvC,EACJW,aACE1K,IAAW,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,IAC/C,KACA,GAEDqK,aAEJkC,UAEGC,EAAgB5C,IAACA,EACpBU,SACAzL,OACA0L,QACEvK,GACEA,EAAMY,WAAW,MAAQZ,EAAMU,SAAS,MACxCV,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACvC,CACE8J,OAAQ,CACNC,aACE,sEAKJgC,EAAgB7C,IAACA,EACpBU,SACAzL,OACA0L,QACEvK,GACEA,EAAMY,WAAW,MAAQZ,EAAMU,SAAS,MACxCV,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACrC,CAAC,YAAa,OAAQ,IAAItD,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aAAc,qDAInBL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAAiB,KAARA,IAGjD,OAAOiK,EACHL,IAACA,EAACM,MAAM,CAACiC,EAAcK,IAAgBnC,WACvCT,IAACA,EAACM,MAAM,CAACiC,EAAcM,IAAgBpC,UAC5C,EAiBDlE,WAAW8D,GACFF,EACJO,OAAOL,GACPM,QACEvK,GACW,OAAVA,GAAmBA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,UACzD,CACE8J,OAAQ,CACNC,aAAc,qDAoBxB,YAAApE,CAAa4D,GACX,OAAOiC,KAAK/F,WAAW8D,EACxB,EAgBDyC,aAAazC,GACJF,EAAEC,QAAQC,GAiBnBzD,KAAKyD,GACIF,EAAEO,OAAOL,GAkBlBxD,KAAKwD,GACIF,EAAEuB,eAAerB,GAiB1BvD,YAAYuD,GACHF,EAAEmB,YAAYjB,GAiBvB0C,mBAAmB1C,GACVF,EAAEC,QAAQC,GAiBnB2C,UAAU3C,GACDF,EAAEO,OAAOL,GAkBlB4C,UAAU5C,GACDF,EAAEuB,eAAerB,GAAaI,WAkBvCyC,aAAa7C,GACJF,EAAEuB,eAAerB,GAiB1B8C,mBAAmB9C,GACVF,EAAEC,QAAQC,GAkBnBlD,YAAYkD,GACHF,EAAEuB,eAAerB,GAkB1BjD,OAAOiD,GACEF,EAAEuB,eAAerB,GAkB1BhD,MAAMgD,GACGF,EAAEuB,eAAerB,GAiB1B/C,WAAW+C,GACFF,EAAEC,QAAQC,GAiBnB9C,QAAQ8C,GACCF,EAAEO,OAAOL,GAiBlB7C,UAAU6C,GACDF,EAAEO,OAAOL,GAiBlB+C,UAAU/C,GACDF,EAAEC,QAAQC,GAiBnBgD,SAAShD,GACAF,EAAEC,QAAQC,GAkBnBiD,QAAQjD,GACCF,EAAEuB,eAAerB,GAiB1BkD,YAAYlD,GACHF,EAAEO,OAAOL,GAiBlBxC,WAAWwC,GACFF,EAAEmB,YAAYjB,GAiBvBvC,WAAWuC,GACFF,EAAEmB,YAAYjB,GAiBvBtC,UAAUsC,GACDF,EAAEmB,YAAYjB,GAkBvBrC,eAAeqC,GACNF,EAAEuB,eAAerB,GAkB1BpC,cAAcoC,GACLF,EAAEuB,eAAerB,GAkB1BnC,eAAemC,GACNF,EAAEuB,eAAerB,GAkB1BlC,YAAYkC,GACHF,EAAEuB,eAAerB,GAkB1BjC,oBAAoBiC,GACXF,EAAEuB,eAAerB,GAkB1BhC,eAAegC,GACNF,EAAEuB,eAAerB,GAiB1BmD,iBAAiBnD,GACRF,EAAEC,QAAQC,GAkBnBoD,kBAAkBpD,GACTF,EAAEuB,eAAerB,GAwB1BqD,SAASrD,GACAA,EACHL,MAAEuB,SAASoC,MAAMvB,IAAI,GAAGC,IAAI,GAC5BrC,IAACA,EACEM,MAAM,CACLN,IAACA,EACEU,SACAzL,OACA0L,QACEvK,IACGqL,MAAMvL,OAAOE,MACH,IAAVA,IACCA,EAAMY,WAAW,MAClBd,OAAOsD,UAAUtD,OAAOE,KACxBF,OAAOE,IAAU,GACjBF,OAAOE,IAAU,GACnB,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,IACrC,CACEwK,OAAQ,CACNC,aAAc,8CAInBL,WAAWpK,GACT,CAAC,YAAa,OAAQ,IAAI5C,SAAS4C,GAEhC,KADAF,OAAOE,KAGf4J,MAAEuB,SAASoC,MAAMvB,IAAI,GAAGC,IAAI,KAE7B5B,WAkBTmD,QAAQvD,GACCF,EACJO,OAAOL,GACPM,QACEvK,GACW,OAAVA,GAAmBA,EAAMZ,QAAU,GAAKY,EAAMU,SAAS,SACzD,CACE8J,OAAQ,CACNC,aAAc,oDAoBxBgD,QAAQxD,GACCF,EAAEO,OAAOL,GAiBlByD,aAAazD,GACJF,EAAEC,QAAQC,GAiBnB0D,UAAU1D,GACDF,EAAEC,QAAQC,GAiBnB2D,SAAS3D,GACAF,EAAEC,QAAQC,GAiBnB4D,QAAQ5D,GACCF,EAAEnJ,WAAW,CAAC,KAAMqJ,GAiB7B5B,QAAQ4B,GACCF,EAAEI,KAAK,CAAC,cAAe,aAAc,QAASF,GAiBvD3B,qBAAqB2B,GACZF,EAAEC,QAAQC,GAiBnB1B,OAAO0B,GACEF,EAAEC,QAAQC,GAiBnBzB,cAAcyB,GACLF,EAAEC,QAAQC,GAiBnBxB,iBAAiBwB,GACRF,EAAEC,QAAQC,GAiBnBvB,WAAWuB,GACFF,EAAEC,QAAQC,GAiBnB6D,YAAY7D,GACHF,EAAEC,QAAQC,GAiBnBrB,SAASqB,GACAF,EAAEC,QAAQC,GAiBnBpB,SAASoB,GACAF,EAAEC,QAAQC,GAiBnBnB,gBAAgBmB,GACPF,EAAEC,QAAQC,GAiBnBlB,OAAOkB,GACEF,EAAEC,QAAQC,GAkBnBjB,OAAOiB,GACEF,EAAEuB,eAAerB,GAkB1BhB,cAAcgB,GACLF,EAAEuB,eAAerB,GAkB1B8D,UAAS,IACAnE,IAACA,EACLU,SACA0D,KAAK,CAAE3L,QAAS,yCAChBgI,YAKD4D,gBAAmBhE,GACvBL,IAACA,EACE8B,OAAO,CACNnK,KAAMsK,WAAWtK,KAAK0I,KAEvBsC,UAGC2B,iBAAoBjE,GACxBL,IAACA,EACE8B,OAAO,CACNzH,QAAS4H,WAAW5H,QAAQgG,GAC5B/F,OAAQ2H,WAAW3H,OAAO+F,GAC1B9F,WAAY0H,WAAW1H,WAAW8F,GAClC7F,UAAWyH,WAAWzH,UAAU6F,GAChC5F,YAAawH,WAAWxH,YAAY4F,GACpC1F,cAAesH,WAAWtH,cAAc0F,GACxCzF,iBAAkBqH,WAAWrH,iBAAiByF,GAC9CxF,cAAeoH,WAAWpH,cAAcwF,KAEzCsC,UAGC4B,aAAgBlE,GACpBL,IAACA,EACE8B,OAAO,CACN/G,OAAQkH,WAAWlH,OAAOsF,GAC1BrF,MAAOiH,WAAWjH,QAClBC,QAASgH,WAAWhH,UACpBC,IAAK+G,WAAW/G,MAChBvH,QAASsO,WAAWtO,QAAQ0M,GAC5B3M,KAAMuO,WAAWvO,KAAK2M,GACtBjN,OAAQ6O,WAAW7O,OAAOiN,GAC1B/E,IAAK2G,WAAW3G,IAAI+E,GACpB9E,WAAY0G,WAAW1G,WAAW8E,GAClC1E,cAAesG,WAAWtG,cAAc0E,GACxCzE,aAAcqG,WAAWrG,aAAayE,GACtCxE,aAAcoG,WAAWpG,aAAawE,GACtC7E,OAAQyG,WAAWzG,OAAO6E,GAC1B5E,MAAOwG,WAAWxG,MAAM4E,GACxB3E,MAAOuG,WAAWvG,MAAM2E,GACxBrE,cAAeiG,WAAWjG,gBAC1BC,aAAcgG,WAAWhG,eACzBd,MAAO8G,WAAW9G,OAAM,GACxBe,qBAAsB+F,WAAW/F,qBAAqBmE,KAEvDsC,UAGC6B,kBAAqBnE,GACzBL,IAACA,EACE8B,OAAO,CACN1F,mBAAoB6F,WAAW7F,mBAAmBiE,GAClDzJ,mBAAoBqL,WAAWrL,mBAAmByJ,GAClD1J,WAAYsL,WAAWtL,YAAW,GAClC0F,SAAU4F,WAAW5F,UAAS,GAC9BC,UAAW2F,WAAW3F,UAAU+D,GAChC9D,WAAY0F,WAAW1F,YAAW,GAClCE,aAAcwF,WAAWxF,cAAa,KAEvCkG,UAGC8B,YAAepE,GACnBL,IAACA,EACE8B,OAAO,CACNlF,KAAMqF,WAAWe,WAAU,GAC3BnG,KAAMoF,WAAWgB,UAAU5C,GAC3BpD,QAASgF,WAAWiB,aAAa7C,KAElCsC,UAGC+B,mBAAsBrE,GAC1BL,IAACA,EACE8B,OAAO,CACNnF,OAAQsF,WAAWkB,mBAAmB9C,GACtClD,YAAa8E,WAAW9E,YAAYkD,GACpCjD,OAAQ6E,WAAW7E,OAAOiD,GAC1BhD,MAAO4E,WAAW5E,MAAMgD,GACxB/C,WAAY2E,WAAW3E,WAAW+C,GAClC9C,QAAS0E,WAAW1E,SAAQ,GAC5BC,UAAWyE,WAAWzE,WAAU,KAEjCmF,UAGCgC,UAAatE,GACjBL,IAACA,EACE8B,OAAO,CACNnF,OAAQsF,WAAWmB,UAAU/C,GAC7B3C,MAAOuE,WAAWoB,SAAShD,GAC3BxD,KAAMoF,WAAWqB,QAAQjD,GACzB1C,SAAUsE,WAAWsB,aAAY,KAElCZ,UAGCiC,aAAgBvE,GACpBL,IAAAA,EAAE8B,OAAO,CACPnF,OAAQsF,WAAWa,aAAazC,GAAawE,WAC7CjI,KAAMqF,WAAWrF,KAAKyD,GAAawE,WACnChI,KAAMoF,WAAWpF,KAAKwD,GAAawE,WACnC/H,YAAamF,WAAWnF,YAAYuD,GAAawE,WACjD9H,aAAckF,WAAWc,mBAAmB1C,GAAawE,WACzD7H,MAAOyH,YAAYpE,GAAawE,WAChC3H,aAAcwH,mBAAmBrE,GAAawE,WAC9CpH,IAAKkH,UAAUtE,GAAawE,aAI1BC,WAAczE,GAClBL,IAACA,EACE8B,OAAO,CACNjE,WAAYoE,WAAWpE,WAAWwC,GAClCvC,WAAYmE,WAAWnE,WAAWuC,GAClCtC,UAAWkE,WAAWlE,UAAUsC,GAChCrC,eAAgBiE,WAAWjE,eAAeqC,GAC1CpC,cAAegE,WAAWhE,cAAcoC,GACxCnC,eAAgB+D,WAAW/D,eAAemC,GAC1ClC,YAAa8D,WAAW9D,YAAYkC,GACpCjC,oBAAqB6D,WAAW7D,oBAAoBiC,GACpDhC,eAAgB4D,WAAW5D,eAAegC,GAC1CtD,aAAckF,WAAWuB,iBAAiBnD,KAE3CsC,UAGCoC,cAAiB1E,GACrBL,IAACA,EACE8B,OAAO,CACNhK,MAAOmK,WAAWyB,SAASrD,GAC3BjH,KAAM6I,WAAW2B,QAAQvD,GACzBlH,KAAM8I,WAAW4B,QAAQxD,GACzBlJ,UAAW8K,WAAW6B,aAAazD,GACnCjJ,OAAQ6K,WAAW8B,UAAU1D,KAE9BsC,UAGCqC,SAAY3E,GAChBL,IAACA,EACE8B,OAAO,CACNnF,OAAQsF,WAAW+B,SAAS3D,GAC5B9B,MAAO0D,WAAWgC,QAAQ5D,KAE3BsC,UAGCsC,YAAe5E,GACnBL,IAACA,EACE8B,OAAO,CACNrD,QAASwD,WAAWxD,QAAQ4B,GAC5B3B,qBAAsBuD,WAAWvD,qBAAqB2B,GACtD1B,OAAQsD,WAAWtD,OAAO0B,GAC1BzB,cAAeqD,WAAWrD,cAAcyB,GACxCxB,iBAAkBoD,WAAWpD,iBAAiBwB,GAC9CvB,WAAYmD,WAAWnD,WAAWuB,KAEnCsC,UAGCuC,YAAe7E,GACnBL,IAACA,EACE8B,OAAO,CACNnF,OAAQsF,WAAWiC,YAAY7D,GAC/BrB,SAAUiD,WAAWjD,SAASqB,GAC9BpB,SAAUgD,WAAWhD,SAASoB,GAC9BnB,gBAAiB+C,WAAW/C,gBAAgBmB,GAC5ClB,OAAQ8C,WAAW9C,OAAOkB,GAC1BjB,OAAQ6C,WAAW7C,OAAOiB,GAC1BhB,cAAe4C,WAAW5C,cAAcgB,KAEzCsC,UAGQwC,mBAAqBnF,IAACA,EAAC8B,OAAO,CACzCqC,UAAWlC,WAAWkC,YACtBtK,UAAWwK,iBAAgB,GAC3BjK,WAAYkK,kBAAiB,GAC7BxJ,OAAQyJ,cAAa,GACrBpI,YAAaqI,mBAAkB,GAC/B9H,OAAQkI,cAAa,GACrBhH,KAAMkH,YAAW,GACjB5N,QAAS6N,eAAc,GACvBzG,GAAI0G,UAAS,GACbxG,MAAOyG,aAAY,GACnBlG,MAAOmG,aAAY,KAIRE,kBAAoBpF,IAACA,EAAC8B,OAAO,CACxCqC,UAAWlC,WAAWkC,YACtBtK,UAAWwK,iBAAgB,GAC3BjK,WAAYkK,kBAAiB,GAC7BxJ,OAAQyJ,cAAa,GACrBpI,YAAaqI,mBAAkB,GAC/B9H,OAAQkI,cAAa,GACrBhH,KAAMkH,YAAW,GACjB5N,QAAS6N,eAAc,GACvBzG,GAAI0G,UAAS,GACbxG,MAAOyG,aAAY,GACnBlG,MAAOmG,aAAY,KAIRG,UAAYrF,IAACA,EAAC8B,OAAO,CAEhCwD,eAAgBrD,WAAWtK,MAAK,GAGhC4N,mBAAoBtD,WAAW5H,SAAQ,GACvCmL,mBAAoBvD,WAAW3H,QAAO,GACtCmL,uBAAwBxD,WAAW1H,YAAW,GAC9CmL,sBAAuBzD,WAAWzH,WAAU,GAC5CmL,uBAAwB1D,WAAWC,YAAW,GAC9C0D,wBAAyB3D,WAAWxH,aAAY,GAChDoL,0BAA2B5D,WAAWtH,eAAc,GACpDmL,6BAA8B7D,WAAWrH,kBAAiB,GAC1DmL,0BAA2B9D,WAAWpH,eAAc,GAGpDmL,cAAe/D,WAAWlH,QAAO,GACjCkL,aAAchE,WAAWjH,QACzBkL,eAAgBjE,WAAWhH,UAC3BkL,WAAYlE,WAAW/G,MACvBkL,aAAcnE,WAAW9G,OAAM,GAC/BkL,eAAgBpE,WAAWtO,SAAQ,GACnC2S,YAAarE,WAAWvO,MAAK,GAC7B6S,cAAetE,WAAW7O,QAAO,GACjCoT,WAAYvE,WAAW3G,KAAI,GAC3BmL,mBAAoBxE,WAAW1G,YAAW,GAC1CmL,cAAezE,WAAWzG,QAAO,GACjCmL,aAAc1E,WAAWxG,OAAM,GAC/BmL,aAAc3E,WAAWvG,OAAM,GAC/BmL,sBAAuB5E,WAAWtG,eAAc,GAChDmL,qBAAsB7E,WAAWrG,cAAa,GAC9CmL,qBAAsB9E,WAAWpG,cAAa,GAC9CmL,sBAAuB/E,WAAWjG,gBAClCiL,qBAAsBhF,WAAWhG,eACjCiL,6BAA8BjF,WAAW/F,sBAAqB,GAG9DiL,kCAAmClF,WAAW7F,oBAAmB,GACjEgL,kCAAmCnF,WAAWrL,oBAAmB,GACjEyQ,yBAA0BpF,WAAWtL,YAAW,GAChD2Q,sBAAuBrF,WAAW5F,UAAS,GAC3CkL,uBAAwBtF,WAAW3F,WAAU,GAC7CkL,yBAA0BvF,WAAW1F,YAAW,GAChDkL,2BAA4BxF,WAAWxF,cAAa,GAGpDiL,cAAezF,WAAWa,cAAa,GACvC6E,YAAa1F,WAAWrF,MAAK,GAC7BgL,YAAa3F,WAAWpF,MAAK,GAC7BgL,oBAAqB5F,WAAWnF,aAAY,GAC5CgL,oBAAqB7F,WAAWc,oBAAmB,GAGnDgF,kBAAmB9F,WAAWe,WAAU,GACxCgF,kBAAmB/F,WAAWgB,WAAU,GACxCgF,qBAAsBhG,WAAWiB,cAAa,GAG9CgF,4BAA6BjG,WAAWkB,oBAAmB,GAC3DgF,kCAAmClG,WAAW9E,aAAY,GAC1DiL,4BAA6BnG,WAAW7E,QAAO,GAC/CiL,2BAA4BpG,WAAW5E,OAAM,GAC7CiL,iCAAkCrG,WAAW3E,YAAW,GACxDiL,8BAA+BtG,WAAW1E,SAAQ,GAClDiL,gCAAiCvG,WAAWzE,WAAU,GAGtDiL,kBAAmBxG,WAAWmB,WAAU,GACxCsF,iBAAkBzG,WAAWoB,UAAS,GACtCsF,gBAAiB1G,WAAWqB,SAAQ,GACpCsF,qBAAsB3G,WAAWsB,aAAY,GAG7CsF,iBAAkB5G,WAAWpE,YAAW,GACxCiL,iBAAkB7G,WAAWnE,YAAW,GACxCiL,gBAAiB9G,WAAWlE,WAAU,GACtCiL,qBAAsB/G,WAAWjE,gBAAe,GAChDiL,oBAAqBhH,WAAWhE,eAAc,GAC9CiL,qBAAsBjH,WAAW/D,gBAAe,GAChDiL,kBAAmBlH,WAAW9D,aAAY,GAC1CiL,2BAA4BnH,WAAW7D,qBAAoB,GAC3DiL,qBAAsBpH,WAAW5D,gBAAe,GAChDiL,kBAAmBrH,WAAWuB,kBAAiB,GAG/C+F,cAAetH,WAAWyB,UAAS,GACnC8F,aAAcvH,WAAW2B,SAAQ,GACjC6F,aAAcxH,WAAW4B,SAAQ,GACjC6F,mBAAoBzH,WAAW6B,cAAa,GAC5C6F,gBAAiB1H,WAAW8B,WAAU,GAGtC6F,UAAW3H,WAAW+B,UAAS,GAC/B6F,SAAU5H,WAAWgC,SAAQ,GAG7B6F,eAAgB7H,WAAWxD,SAAQ,GACnCsL,8BAA+B9H,WAAWvD,sBAAqB,GAC/DsL,cAAe/H,WAAWtD,QAAO,GACjCsL,sBAAuBhI,WAAWrD,eAAc,GAChDsL,yBAA0BjI,WAAWpD,kBAAiB,GACtDsL,iBAAkBlI,WAAWnD,YAAW,GAGxCsL,aAAcnI,WAAWiC,aAAY,GACrCmG,eAAgBpI,WAAWjD,UAAS,GACpCsL,eAAgBrI,WAAWhD,UAAS,GACpCsL,wBAAyBtI,WAAW/C,iBAAgB,GACpDsL,aAAcvI,WAAW9C,QAAO,GAChCsL,cAAexI,WAAW7C,QAAO,GACjCsL,qBAAsBzI,WAAW5C,eAAc,KAWpCsL,KAAOtF,UAAU1C,UAAUiI,MAAM7U,QAAQ8U,KAW/C,SAASC,eAAeC,GAC7B,OAAO5F,mBAAmBxC,UAAUiI,MAAMG,EAC5C,CAWO,SAASC,cAAcD,GAC5B,OAAO3F,kBAAkBzC,UAAUiI,MAAMG,EAC3C,CA8BA,SAAS7K,gBAAgBlH,EAAOiS,GAE9B,MAAMC,EAAelS,EAAMzE,KAAKE,KAAK,KAG/B0W,EAAe,yBAAyBD,IAG9C,GAAIlS,EAAMoS,OAASpL,MAAEqL,aAAaC,aAEhC,OAAItS,EAAMuS,WAAavL,MAAEwL,cAAcrT,UAC9B,CACLM,QAAS,GAAG0S,8BAKT,CACL1S,QAAS,GAAG0S,qBAAgCF,EAAQQ,iBAKxD,GAAIzS,EAAMoS,OAASpL,MAAEqL,aAAaK,QAE5B1S,EAAM4H,QAAQC,aAChB,MAAO,CACLpI,QAAS,GAAG0S,OAAkBnS,EAAM4H,QAAQC,2BAA2BoK,EAAQU,UAMrF,GAAI3S,EAAMoS,OAASpL,MAAEqL,aAAaO,cAAe,CAE/C,IAAInT,EAAU,oCAAoCyS,OAYlD,OATAlS,EAAM6S,YAAYjM,SAASxJ,IACzB,MAAM0V,EAAQ1V,EAAM0C,OAAO,GAAGL,QAAQ0J,QAAQ,KAC9C1J,IACc,IAAZqT,EACI,GAAG1V,EAAM0C,OAAO,GAAGL,YAAYqH,UAAUgM,GACzC,GAAG1V,EAAM0C,OAAO,GAAGL,WAAW,IAI/B,CACLA,UAEH,CAGD,MAAO,CACLA,QAAS,GAAG0S,OAAkBF,EAAQQ,gBAE1C,CCtuFA,MAAMM,oBAAoBC,MAQxB,WAAAC,CAAYxT,EAASyT,GACnBC,QAEA7J,KAAK7J,QAAUA,EACf6J,KAAK5J,aAAeD,EAEhByT,IACF5J,KAAK4J,WAAaA,EAErB,CASD,SAAAE,CAAUF,GAGR,OAFA5J,KAAK4J,WAAaA,EAEX5J,IACR,CAUD,QAAA+J,CAAS/T,GAgBP,OAfAgK,KAAKhK,MAAQA,EAETA,EAAMgU,OACRhK,KAAKgK,KAAOhU,EAAMgU,MAGhBhU,EAAM4T,aACR5J,KAAK4J,WAAa5T,EAAM4T,YAGtB5T,EAAMK,QACR2J,KAAK5J,aAAeJ,EAAMG,QAC1B6J,KAAK3J,MAAQL,EAAMK,OAGd2J,IACR,ECrCH,MAAMtG,cAAgBuQ,mBAAmB3S,eAGnC4S,gBAAkB/Z,SAASuJ,eAgB1B,SAASyQ,WAAWC,GAAc,GACvC,OAAOA,EAAcF,gBAAkBxQ,aACzC,CA2BO,SAAS2Q,iBAAiBC,EAAgB,GAAIC,EAAU,IAE7D,IAAI9B,EAAgB,CAAA,EAGhB+B,EAAa,CAAA,EAGjB,GAAID,GAAWja,MAAMC,QAAQga,IAAYA,EAAQrX,OAAQ,CACvD,IAEEuV,EAAgBD,eACdiC,gBAAgBF,EAAS7Q,cAAcG,aAE1C,CAAC,MAAO7D,GACPO,aACE,EACAP,EAAMQ,OACN,4EAEH,CAED,IAEEgU,EAAa9B,cAAcgC,mBAAmB1N,YAAauN,GAC5D,CAAC,MAAOvU,GACPO,aACE,EACAP,EAAMQ,OACN,4CAEH,CACF,CAGD,GACE8T,GACAxX,SAASwX,IACT7Z,OAAOwC,KAAKqX,GAAepX,OAE3B,IAEEoX,EAAgB9B,eAAe8B,EAChC,CAAC,MAAOtU,GACPO,aACE,EACAP,EAAMQ,OACN,+CAEH,CAaH,OATAmU,qBACErT,cACAoC,cACA+O,EACA+B,EACAF,GAIK5Q,aACT,CAeO,SAASkR,cAAcA,EAAeC,GAAc,GAgBzD,OAdIA,IAEFpa,OAAOwC,KAAKiX,iBAAiB5M,SAAS9M,WAC7B0Z,gBAAgB1Z,EAAI,IAI7Bsa,aAAaZ,gBAAiB/Z,SAASuJ,iBAIzCoR,aAAaZ,gBAAiBU,GAGvBV,eACT,CAYO,SAASY,aAAaC,EAAiBC,GAE5C,GAAIlY,SAASiY,IAAoBjY,SAASkY,GACxC,IAAK,MAAOxa,EAAKsD,KAAUrD,OAAOwa,QAAQD,GACxCD,EAAgBva,GACdsC,SAASgB,KACRoJ,cAAchM,SAASV,SACCqF,IAAzBkV,EAAgBva,GACZsa,aAAaC,EAAgBva,GAAMsD,QACzB+B,IAAV/B,EACEA,EACAiX,EAAgBva,IAAQ,KAKpC,OAAOua,CACT,CAkBO,SAASG,gBAAgBC,GAE9B,MAAMH,EAAa,CAAA,EAGnB,GAAIlY,SAASqY,GAEX,IAAK,MAAO3a,EAAKsD,KAAUrD,OAAOwa,QAAQE,GAAa,CAErD,MAAMC,EAAkBpO,YAAYxM,GAChCwM,YAAYxM,GAAKe,MAAM,KACvB,GAIJ6Z,EAAgBC,QACd,CAACC,EAAKC,EAAM/B,IACT8B,EAAIC,GACHH,EAAgBlY,OAAS,IAAMsW,EAAQ1V,EAAQwX,EAAIC,IAAS,IAChEP,EAEH,MAED5V,IACE,EACA,mFAKJ,OAAO4V,CACT,CAgBO,SAASQ,eAAexB,EAAMyB,EAAc1N,GAAc,GAE/D,IAAKoM,aAAajO,MAAMM,WACtB,OAAOiP,EAGT,IAEE,OAAO9L,WAAWqK,GAAMjM,GAAauK,MAAMmD,EAC5C,CAAC,MAAOzV,GASP,MAPAO,aACE,EACAP,EAAMQ,OACN,oBAAoBwT,6BAIhB,IAAIP,YACR,oBAAoBO,4BACpB,IAEH,CACH,CAcO,SAAS0B,gBAAgBjD,EAAe1K,GAAc,GAE3D,IAAKoM,aAAajO,MAAMM,WACtB,OAAOiM,EAGT,IAEE,OAAO1K,EACHyK,eAAeC,GACfC,cAAcD,EACnB,CAAC,MAAOzS,GAKP,MAHAO,aAAa,EAAGP,EAAMQ,OAAQ,yCAGxB,IAAIiT,YAAY,wCAAyC,IAChE,CACH,CAoBO,SAASkC,gBACdvO,OACA5K,UAAW,EACXoZ,gBAAiB,GAEjB,IAEE,IAAK9Y,SAASsK,SAA6B,iBAAXA,OAE9B,OAAO,KAIT,MAAMyO,aACc,iBAAXzO,OACHwO,eACEE,KAAK,IAAI1O,WACT2O,KAAKzD,MAAMlL,QACbA,OAGA4O,mBAAqBC,kBACzBJ,aACAD,gBACA,GAIIM,cAAgBN,eAClBG,KAAKzD,MACH2D,kBAAkBJ,aAAcD,gBAAgB,IAChD,CAACO,EAAGrY,QACe,iBAAVA,OAAsBA,MAAMY,WAAW,YAC1CoX,KAAK,IAAIhY,UACTA,QAERiY,KAAKzD,MAAM0D,oBAGf,OAAOxZ,SAAWwZ,mBAAqBE,aACxC,CAAC,MAAOlW,GAEP,OAAO,IACR,CACH,CAsFA,SAASiU,mBAAmB7M,GAC1B,MAAMzE,EAAU,CAAA,EAGhB,IAAK,MAAOqR,EAAMjX,KAAStC,OAAOwa,QAAQ7N,GACxC,GAAI3M,OAAOC,UAAUC,eAAeC,KAAKmC,EAAM,SAAU,CAEvD,MAAMqZ,EAAS/D,KAAKtV,EAAK0E,SAEvBkB,EAAQqR,GADNoC,QACcA,EAEArZ,EAAKe,KAE7B,MACM6E,EAAQqR,GAAQC,mBAAmBlX,GAKvC,OAAO4F,CACT,CAwBA,SAASgS,qBAAqBvN,EAAQzE,EAAS0T,EAAWC,EAAQC,GAChE9b,OAAOwC,KAAKmK,GAAQE,SAAS9M,IAE3B,MAAM+M,EAAQH,EAAO5M,GAGfgc,EAAYH,GAAaA,EAAU7b,GACnCic,EAASH,GAAUA,EAAO9b,GAC1Bkc,EAAYH,GAAaA,EAAU/b,GAGzC,QAA2B,IAAhB+M,EAAMzJ,MACf6W,qBAAqBpN,EAAO5E,EAAQnI,GAAMgc,EAAWC,EAAQC,OACxD,CAEDF,UACF7T,EAAQnI,GAAOgc,GAIjB,MAAMJ,EAAS/D,KAAK9K,EAAM9F,SACtB8F,EAAM9F,WAAW4Q,MAAjB9K,MAAyB6O,IAC3BzT,EAAQnI,GAAO4b,GAIbK,UACF9T,EAAQnI,GAAOic,GAIbC,UACF/T,EAAQnI,GAAOkc,EAElB,IAEL,CAsBO,SAAST,kBAAkBtT,EAASiT,EAAgBe,GAiCzD,OAAOZ,KAAKa,UAAUjU,GAhCG,CAACwT,EAAGrY,KAO3B,GALqB,iBAAVA,IACTA,EAAQA,EAAMnB,QAKG,mBAAVmB,GACW,iBAAVA,GACNA,EAAMY,WAAW,aACjBZ,EAAMU,SAAS,KACjB,CAEA,GAAIoX,EAEF,OAAOe,EAEH,YAAY7Y,EAAQ,IAAI+Y,WAAW,OAAQ,eAE3C,WAAW/Y,EAAQ,IAAI+Y,WAAW,OAAQ,cAG9C,MAAM,IAAInD,KAEb,CAGD,OAAO5V,CAAK,IAImC+Y,WAC/CF,EAAqB,yBAA2B,qBAChD,GAEJ,CAiBA,SAASlC,gBAAgBF,EAASuC,GAEhC,MAAMC,EAAcxC,EAAQyC,WACzBC,GAAkC,eAA1BA,EAAIhc,QAAQ,KAAM,MAIvBic,EAAiBH,GAAc,GAAMxC,EAAQwC,EAAc,GAGjE,GAAIG,GAAkBJ,EAAmBxY,mBACvC,IAEE,OAAOqX,gBACLlX,GAAAA,aAAanD,gBAAgB4b,GAAiB,SAC9C,EACAJ,EAAmBhT,mBAEtB,CAAC,MAAO9D,GACPD,aACE,EACAC,EACA,sDAAsDkX,UAEzD,CAIH,MAAO,EACT,CAkBA,SAASxC,mBAAmB1N,EAAauN,GAEvC,MAAMC,EAAa,CAAA,EAGnB,IAAK,IAAI2C,EAAI,EAAGA,EAAI5C,EAAQrX,OAAQia,IAAK,CACvC,MAAMC,EAAS7C,EAAQ4C,GAAGlc,QAAQ,KAAM,IAGlCma,EAAkBpO,EAAYoQ,GAChCpQ,EAAYoQ,GAAQ7b,MAAM,KAC1B,GAGJ6Z,EAAgBC,QAAO,CAACC,EAAKC,EAAM/B,KACjC,GAAI4B,EAAgBlY,OAAS,IAAMsW,EAAO,CACxC,MAAM1V,EAAQyW,IAAU4C,GACnBrZ,GACHsB,IACE,EACA,yCAAyCgY,yCAG7C9B,EAAIC,GAAQzX,GAAS,IACtB,WAAwB+B,IAAdyV,EAAIC,KACbD,EAAIC,GAAQ,IAEd,OAAOD,EAAIC,EAAK,GACff,EACJ,CAGD,OAAOA,CACT,CCxqBO6C,eAAeC,MAAMC,EAAKC,EAAiB,IAChD,OAAO,IAAIC,SAAQ,CAACC,EAASC,KAC3BC,mBAAmBL,GAChBM,IAAIN,EAAKC,GAAiBM,IACzB,IAAIC,EAAe,GAGnBD,EAASE,GAAG,QAASC,IACnBF,GAAgBE,CAAK,IAIvBH,EAASE,GAAG,OAAO,KACZD,GACHJ,EAAO,qCAETG,EAASI,KAAOH,EAChBL,EAAQI,EAAS,GACjB,IAEHE,GAAG,SAAUhY,IACZ2X,EAAO3X,EAAM,GACb,GAER,CAwEA,SAAS4X,mBAAmBL,GAC1B,OAAOA,EAAI7Y,WAAW,SAAWyZ,MAAQC,IAC3C,CCnGA,MAAMC,MAAQ,CACZrW,OAAQ,8BACRsW,eAAgB,CAAE,EAClBC,QAAS,GACTC,UAAW,IAeNnB,eAAeoB,oBACpBC,EACAC,GAEA,IACE,IAAIC,EAGJ,MAAM1W,EAAY2W,eAGZC,EAAe3c,KAAAA,KAAK+F,EAAW,iBAC/B6W,EAAa5c,KAAAA,KAAK+F,EAAW,cAOnC,IAJCf,GAAUA,WAACe,IAAcd,GAASA,UAACc,EAAW,CAAE8W,WAAW,KAIvD7X,GAAAA,WAAW2X,IAAiBJ,EAAkBzW,WACjD7C,IAAI,EAAG,yDACPwZ,QAAuBK,aACrBP,EACAC,EACAI,OAEG,CACL,IAAIG,GAAgB,EAGpB,MAAMC,EAAWpD,KAAKzD,MAAM7T,GAAYA,aAACqa,GAAe,QAIxD,GAAIK,EAASC,SAAW9e,MAAMC,QAAQ4e,EAASC,SAAU,CACvD,MAAMC,EAAY,CAAA,EAClBF,EAASC,QAAQ9R,SAASgS,GAAOD,EAAUC,GAAK,IAChDH,EAASC,QAAUC,CACpB,CAGD,MAAMlX,YAAEA,EAAWE,cAAEA,EAAaC,iBAAEA,GAClCoW,EACIa,EACJpX,EAAYjF,OAASmF,EAAcnF,OAASoF,EAAiBpF,OAK3Dic,EAASpX,UAAY2W,EAAkB3W,SACzC3C,IACE,EACA,yEAEF8Z,GAAgB,GAEhBze,OAAOwC,KAAKkc,EAASC,SAAW,CAAE,GAAElc,SAAWqc,GAE/Cna,IACE,EACA,+EAEF8Z,GAAgB,GAGhBA,GAAiB7W,GAAiB,IAAIjF,MAAMoc,IAC1C,IAAKL,EAASC,QAAQI,GAKpB,OAJApa,IACE,EACA,eAAeoa,iDAEV,CACR,IAKDN,EACFN,QAAuBK,aACrBP,EACAC,EACAI,IAGF3Z,IAAI,EAAG,uDAGPiZ,MAAME,QAAU9Z,GAAAA,aAAasa,EAAY,QAGzCH,EAAiBO,EAASC,QAG1Bf,MAAMG,UAAYiB,eAAepB,MAAME,SAE1C,OAIKmB,sBAAsBhB,EAAmBE,EAChD,CAAC,MAAO5Y,GACP,MAAM,IAAIyT,YACR,8EACA,KACAM,SAAS/T,EACZ,CACH,CASO,SAAS2Z,uBACd,OAAOtB,MAAMG,SACf,CAWOnB,eAAeuC,wBAAwBC,GAE5C,MAAMlX,EAAUwR,aAGhBxR,EAAQb,WAAWC,QAAU8X,QAGvBpB,oBAAoB9V,EAAQb,WAAYa,EAAQyB,OAAOM,MAC/D,CAWO,SAAS+U,eAAeK,GAC7B,OAAOA,EACJtS,UAAU,EAAGsS,EAAajQ,QAAQ,OAClC5O,QAAQ,KAAM,IACdA,QAAQ,KAAM,IACdA,QAAQ,MAAO,IACf0B,MACL,CAYO,SAASod,kBAAkBC,GAChC,OAAOA,EAAW/e,QAChB,qEACA,GAEJ,CAoBO,SAAS4d,eACd,OAAOvd,gBAAgB6Y,aAAarS,WAAWI,UACjD,CAuBAmV,eAAe4C,uBACbC,EACA1C,EACAoB,EACAuB,GAAmB,GAGfD,EAAO1b,SAAS,SAClB0b,EAASA,EAAO1S,UAAU,EAAG0S,EAAOhd,OAAS,IAE/CkC,IAAI,EAAG,6BAA6B8a,QAGpC,MAAMpC,QAAiBR,MAAM,GAAG4C,OAAa1C,GAG7C,GAA4B,MAAxBM,EAASlE,YAA8C,iBAAjBkE,EAASI,KAAkB,CACnE,GAAIU,EAAgB,CAElBA,EADmBmB,kBAAkBG,IACR,CAC9B,CACD,OAAOpC,EAASI,IACjB,CAGD,GAAIiC,EACF,MAAM,IAAI1G,YACR,+BAA+ByG,2EAAgFpC,EAASlE,eACxH,KACAG,SAAS+D,GAEX1Y,IACE,EACA,+BAA+B8a,6DAGrC,CAiBA7C,eAAeqC,sBAAsBhB,EAAmBE,EAAiB,IACvE,MAAMwB,EAAc,CAClBrY,QAAS2W,EAAkB3W,QAC3BqX,QAASR,GAIXP,MAAMC,eAAiB8B,EAEvBhb,IAAI,EAAG,mCACP,IACEib,GAAaA,cACXle,UAAK0c,eAAgB,iBACrB9C,KAAKa,UAAUwD,GACf,OAEH,CAAC,MAAOpa,GACP,MAAM,IAAIyT,YACR,4CACA,KACAM,SAAS/T,EACZ,CACH,CAuBAqX,eAAeiD,cACbnY,EACAE,EACAE,EACAoW,EACAC,GAGA,IAAI2B,EACJ,MAAM7P,EAAYiO,EAAmBrU,KAC/BqG,EAAYgO,EAAmBpU,KAGrC,GAAImG,GAAaC,EACf,IACE4P,EAAa,IAAIC,gBAAAA,gBAAgB,CAC/BlW,KAAMoG,EACNnG,KAAMoG,GAET,CAAC,MAAO3K,GACP,MAAM,IAAIyT,YACR,0CACA,KACAM,SAAS/T,EACZ,CAIH,MAAMwX,EAAiB+C,EACnB,CACEE,MAAOF,EACP5V,QAASgU,EAAmBhU,SAE9B,GAEE+V,EAAmB,IACpBvY,EAAY1B,KAAKyZ,GAClBD,uBAAuB,GAAGC,IAAU1C,EAAgBoB,GAAgB,QAEnEvW,EAAc5B,KAAKyZ,GACpBD,uBAAuB,GAAGC,IAAU1C,EAAgBoB,QAEnDrW,EAAc9B,KAAKyZ,GACpBD,uBAAuB,GAAGC,IAAU1C,MAKxC,aAD6BC,QAAQkD,IAAID,IACnBve,KAAK,MAC7B,CAoBAkb,eAAe4B,aAAaP,EAAmBC,EAAoBI,GAEjE,MAAMP,EAC0B,WAA9BE,EAAkB3W,QACd,KACA,GAAG2W,EAAkB3W,UAGrBC,EAAS0W,EAAkB1W,QAAUqW,MAAMrW,OAEjD,IACE,MAAM4W,EAAiB,CAAA,EAuCvB,OArCAxZ,IACE,EACA,iDAAiDoZ,GAAa,aAGhEH,MAAME,cAAgB+B,cACpB,IACK5B,EAAkBvW,YAAY1B,KAAKma,GACpCpC,EAAY,GAAGxW,KAAUwW,KAAaoC,IAAM,GAAG5Y,KAAU4Y,OAG7D,IACKlC,EAAkBrW,cAAc5B,KAAK6Y,GAChC,QAANA,EACId,EACE,GAAGxW,UAAewW,aAAqBc,IACvC,GAAGtX,kBAAuBsX,IAC5Bd,EACE,GAAGxW,KAAUwW,aAAqBc,IAClC,GAAGtX,aAAkBsX,SAE1BZ,EAAkBpW,iBAAiB7B,KAAK0W,GACzCqB,EACI,GAAGxW,WAAgBwW,gBAAwBrB,IAC3C,GAAGnV,sBAA2BmV,OAGtCuB,EAAkBnW,cAClBoW,EACAC,GAIFP,MAAMG,UAAYiB,eAAepB,MAAME,SAGvC8B,GAAAA,cAActB,EAAYV,MAAME,SACzBK,CACR,CAAC,MAAO5Y,GACP,MAAM,IAAIyT,YACR,uDACA,KACAM,SAAS/T,EACZ,CACH,CCndO,SAAS6a,kBACdC,WAAWC,WAAa,WACtB,MAAO,CAAEC,SAAU,EACvB,CACA,CAcO3D,eAAe4D,YAAYC,EAAepE,GAE/C,MAAM3C,WAAEA,EAAUgH,WAAEA,EAAUC,MAAEA,EAAKC,KAAEA,GAASP,WAIhDA,WAAWQ,cAAgBF,GAAM,EAAO,CAAE,EAAEjH,KAG5CrP,OAAOyW,kBAAmB,EAC1BF,EAAKP,WAAWU,MAAM9gB,UAAW,QAAQ,SAAU+gB,EAASC,EAAaC,KAEvED,EAAcN,EAAMM,EAAa,CAC/BE,UAAW,CACTC,SAAS,GAEXC,YAAa,CACXC,OAAQ,CACNC,MAAO,CACLH,SAAS,KAOfI,QAAS,CAAE,KAGAF,QAAU,IAAIzU,SAAQ,SAAUyU,GAC3CA,EAAOG,WAAY,CACzB,IAGSpX,OAAOqX,qBACVrX,OAAOqX,mBAAqBrB,WAAWsB,SAASpS,KAAM,UAAU,KAC9DlF,OAAOyW,kBAAmB,CAAI,KAIlCE,EAAQ7b,MAAMoK,KAAM,CAAC0R,EAAaC,GACtC,IAEEN,EAAKP,WAAWuB,OAAO3hB,UAAW,QAAQ,SAAU+gB,EAASa,EAAO3Z,GAClE8Y,EAAQ7b,MAAMoK,KAAM,CAACsS,EAAO3Z,GAChC,IAGE,MAAM+G,EAAoB,CACxB4S,MAAO,CAELJ,WAAW,EAEXhZ,OAAQgY,EAAchY,OACtBC,MAAO+X,EAAc/X,OAEvByY,UAAW,CAETC,SAAS,IAKPH,EAAc,IAAIa,SAAS,UAAUrB,EAAcxY,QAArC,GAGdiB,EAAe,IAAI4Y,SAAS,UAAUrB,EAAcvX,eAArC,GAGfD,EAAgB,IAAI6Y,SAAS,UAAUrB,EAAcxX,gBAArC,GAGhB8Y,EAAepB,GACnB,EACAzX,EACA+X,EAEAhS,GAII+S,EAAgB3F,EAAmB/S,SACrC,IAAIwY,SAAS,UAAUzF,EAAmB/S,WAA1C,GACA,KAGA+S,EAAmBzY,YACrB,IAAIke,SAAS,UAAWzF,EAAmBzY,WAA3C,CAAuDqd,GAIrDhY,GACFyX,EAAWzX,GAIboX,WAAWI,EAAcpgB,QAAQ,YAAa0hB,EAAcC,GAG5D,MAAMC,EAAiBvI,IAGvB,IAAK,MAAMoB,KAAQmH,EACmB,mBAAzBA,EAAenH,WACjBmH,EAAenH,GAK1B4F,EAAWL,WAAWQ,eAGtBR,WAAWQ,cAAgB,EAC7B,CC5HA,MAAMqB,SAAWle,GAAYA,aAC3BtC,UAAK7C,YAAW,YAAa,iBAC7B,QAIF,IAAIsjB,QAAU,KAmCPvF,eAAewF,cAAcC,GAElC,MAAMrW,MAAEA,EAAKP,MAAEA,GAAUiO,cAGjB9P,OAAQ0Y,KAAiBC,GAAiBvW,EAG5CwW,EAAgB,CACpBvW,UAAUR,EAAMK,kBAAmB,QACnC2W,YAAa,MACb7d,KAAMyd,GAAiB,GACvBK,cAAc,EACdC,eAAe,EACfC,cAAc,EACdC,oBAAoB,EACpBC,gBAAiB,QACbR,GAAgBC,GAItB,IAAKJ,QAAS,CAEZ,IAAIY,EAAW,EAEf,MAAMC,EAAOpG,UACX,IACEjY,IACE,EACA,yDAAyDoe,OAI3DZ,cAAgBrb,UAAUmc,OAAOT,EAClC,CAAC,MAAOjd,GAQP,GAPAD,aACE,EACAC,EACA,oDAIEwd,EAAW,IAOb,MAAMxd,EANNZ,IAAI,EAAG,sCAAsCoe,uBAGvC,IAAI/F,SAASK,GAAa6F,WAAW7F,EAAU,aAC/C2F,GAIT,GAGH,UACQA,IAGyB,UAA3BR,EAAcvW,UAChBtH,IAAI,EAAG,6CAIL2d,GACF3d,IAAI,EAAG,4CAEV,CAAC,MAAOY,GACP,MAAM,IAAIyT,YACR,gEACA,KACAM,SAAS/T,EACZ,CAED,IAAK4c,QACH,MAAM,IAAInJ,YAAY,2CAA4C,IAErE,CAGD,OAAOmJ,OACT,CAQOvF,eAAeuG,eAEhBhB,SAAWA,QAAQiB,iBACfjB,QAAQkB,QAEhBlB,QAAU,KACVxd,IAAI,EAAG,gCACT,CAgBOiY,eAAe0G,QAAQC,GAE5B,IAAKpB,UAAYA,QAAQiB,UACvB,MAAM,IAAIpK,YAAY,0CAA2C,KAgBnE,GAZAuK,EAAaC,WAAarB,QAAQmB,gBAG5BC,EAAaC,KAAKC,iBAAgB,SAGlCC,gBAAgBH,EAAaC,MAGnCG,eAAeJ,EAAaC,OAGvBD,EAAaC,MAAQD,EAAaC,KAAKI,WAC1C,MAAM,IAAI5K,YAAY,2CAA4C,IAEtE,CAkBO4D,eAAeiH,UAAUN,EAAcO,GAAY,GACxD,IACE,GAAIP,EAAaC,OAASD,EAAaC,KAAKI,WAgB1C,OAfIE,SAEIP,EAAaC,KAAKO,KAAK,cAAe,CAC1CC,UAAW,2BAIPN,gBAAgBH,EAAaC,aAG7BD,EAAaC,KAAKS,UAAS,KAC/BjlB,SAASklB,KAAKC,UACZ,4DAA4D,KAG3D,CAEV,CAAC,MAAO5e,GACPD,aACE,EACAC,EACA,yBAAyBge,EAAaa,mDAIxCb,EAAac,UAAY3K,aAAa7O,KAAKG,UAAY,CACxD,CACD,OAAO,CACT,CAiBO4R,eAAe0H,iBAAiBd,EAAMnH,GAE3C,MAAMkI,EAAoB,GAGpBhb,EAAY8S,EAAmB9S,UACrC,GAAIA,EAAW,CACb,MAAMib,EAAa,GAUnB,GAPIjb,EAAUkG,IACZ+U,EAAW3e,KAAK,CACd4e,QAASlb,EAAUkG,KAKnBlG,EAAUoG,MACZ,IAAK,MAAMtJ,KAAQkD,EAAUoG,MAAO,CAClC,MAAM+U,GAAWre,EAAKpC,WAAW,QAGjCugB,EAAW3e,KACT6e,EACI,CACED,QAASzgB,GAAAA,aAAanD,gBAAgBwF,GAAO,SAE/C,CACEyW,IAAKzW,GAGd,CAGH,IAAK,MAAMse,KAAcH,EACvB,IACED,EAAkB1e,WAAW2d,EAAKoB,aAAaD,GAChD,CAAC,MAAOpf,GACPD,aAAa,EAAGC,EAAO,8CACxB,CAEHif,EAAW/hB,OAAS,EAGpB,MAAMoiB,EAAc,GACpB,GAAItb,EAAUmG,IAAK,CACjB,IAAIoV,EAAavb,EAAUmG,IAAIqV,MAAM,uBACrC,GAAID,EAEF,IAAK,IAAIE,KAAiBF,EACpBE,IACFA,EAAgBA,EACbxkB,QAAQ,OAAQ,IAChBA,QAAQ,UAAW,IACnBA,QAAQ,KAAM,IACdA,QAAQ,KAAM,IACdA,QAAQ,IAAK,IACbA,QAAQ,MAAO,IACf0B,OAGC8iB,EAAc/gB,WAAW,QAC3B4gB,EAAYhf,KAAK,CACfiX,IAAKkI,IAEE3I,EAAmBxY,oBAC5BghB,EAAYhf,KAAK,CACfrE,KAAME,KAAAA,KAAK7C,YAAWmmB,MAQhCH,EAAYhf,KAAK,CACf4e,QAASlb,EAAUmG,IAAIlP,QAAQ,sBAAuB,KAAO,MAG/D,IAAK,MAAMykB,KAAeJ,EACxB,IACEN,EAAkB1e,WAAW2d,EAAK0B,YAAYD,GAC/C,CAAC,MAAO1f,GACPD,aACE,EACAC,EACA,+CAEH,CAEHsf,EAAYpiB,OAAS,CACtB,CACF,CACD,OAAO8hB,CACT,CAeO3H,eAAeuI,mBAAmB3B,EAAMe,GAC7C,IACE,IAAK,MAAMa,KAAYb,QACfa,EAASC,gBAIX7B,EAAKS,UAAS,KAElB,GAA0B,oBAAf5D,WAA4B,CAErC,MAAMiF,EAAYjF,WAAWkF,OAG7B,GAAI1lB,MAAMC,QAAQwlB,IAAcA,EAAU7iB,OAExC,IAAK,MAAM+iB,KAAYF,EACrBE,GAAYA,EAASC,UAErBpF,WAAWkF,OAAOxkB,OAGvB,CAGD,SAAU2kB,GAAmB1mB,SAAS2mB,qBAAqB,WAErD,IAAMC,GAAkB5mB,SAAS2mB,qBAAqB,aAElDE,GAAiB7mB,SAAS2mB,qBAAqB,QAGzD,IAAK,MAAMG,IAAW,IACjBJ,KACAE,KACAC,GAEHC,EAAQC,QACT,GAEJ,CAAC,MAAOxgB,GACPD,aAAa,EAAGC,EAAO,8CACxB,CACH,CAYAqX,eAAe8G,gBAAgBF,SAEvBA,EAAKwC,WAAW9D,SAAU,CAAE8B,UAAW,2BAGvCR,EAAKoB,aAAa,CAAEpjB,KAAME,KAAIA,KAAC0c,eAAgB,sBAG/CoF,EAAKS,SAAS7D,gBACtB,CAWA,SAASuD,eAAeH,GAEtB,MAAMxX,MAAEA,GAAU0N,aAGlB8J,EAAKjG,GAAG,aAAaX,UAGf4G,EAAKI,UAER,IAIC5X,EAAMpC,QAAUoC,EAAMG,iBACxBqX,EAAKjG,GAAG,WAAY7X,IAClBR,QAAQP,IAAI,WAAWe,EAAQ+X,SAAS,GAG9C,CC5cA,IAAAwI,YAAe,IAAM,yXCINC,YAAC/d,GAAQ,8LAQlB8d,8EAIE9d,wCCaDyU,eAAeuJ,gBAAgB3C,EAAM/C,EAAepE,GAEzD,MAAMkI,EAAoB,GAE1B,IACE,IAAI6B,GAAQ,EAGZ,GAAI3F,EAActY,IAAK,CAIrB,GAHAxD,IAAI,EAAG,mCAGoB,QAAvB8b,EAAc9f,KAChB,OAAO8f,EAActY,IAIvBie,GAAQ,QAGF5C,EAAKwC,WAAWE,YAAYzF,EAActY,KAAM,CACpD6b,UAAW,oBAEnB,MACMrf,IAAI,EAAG,2CAGD6e,EAAKS,SAASzD,YAAaC,EAAepE,GAMlDkI,EAAkB1e,cACNye,iBAAiBd,EAAMnH,IAInC,MAAMgK,EAAOD,QACH5C,EAAKS,UAAUtb,IACnB,MAAM2d,EAAatnB,SAASunB,cAC1B,sCAIIC,EAAcF,EAAW7d,OAAOge,QAAQpjB,MAAQsF,EAChD+d,EAAaJ,EAAW5d,MAAM+d,QAAQpjB,MAAQsF,EAUpD,OANA3J,SAASklB,KAAKyC,MAAMC,KAAOje,EAI3B3J,SAASklB,KAAKyC,MAAME,OAAS,MAEtB,CACLL,cACAE,aACD,GACAI,WAAWrG,EAAc9X,cACtB6a,EAAKS,UAAS,KAElB,MAAMuC,YAAEA,EAAWE,WAAEA,GAAerc,OAAOgW,WAAWkF,OAAO,GAO7D,OAFAvmB,SAASklB,KAAKyC,MAAMC,KAAO,EAEpB,CACLJ,cACAE,aACD,KAIDK,EAAEA,EAACC,EAAEA,SAAYC,eAAezD,GAGhC0D,EAAiB1jB,KAAK2jB,IAC1B3jB,KAAK4jB,KAAKf,EAAKG,aAAe/F,EAAchY,SAIxC4e,EAAgB7jB,KAAK2jB,IACzB3jB,KAAK4jB,KAAKf,EAAKK,YAAcjG,EAAc/X,QAU7C,IAAI4e,EAEJ,aARM9D,EAAK+D,YAAY,CACrB9e,OAAQye,EACRxe,MAAO2e,EACPG,kBAAmBpB,EAAQ,EAAIU,WAAWrG,EAAc9X,SAKlD8X,EAAc9f,MACpB,IAAK,MACH2mB,QAAeG,WAAWjE,GAC1B,MACF,IAAK,MACL,IAAK,OACH8D,QAAeI,aACblE,EACA/C,EAAc9f,KACd,CACE+H,MAAO2e,EACP5e,OAAQye,EACRH,IACAC,KAEFvG,EAActX,sBAEhB,MACF,IAAK,MACHme,QAAeK,WACbnE,EACA0D,EACAG,EACA5G,EAActX,sBAEhB,MACF,QACE,MAAM,IAAI6P,YACR,uCAAuCyH,EAAc9f,QACrD,KAMN,aADMwkB,mBAAmB3B,EAAMe,GACxB+C,CACR,CAAC,MAAO/hB,GAEP,aADM4f,mBAAmB3B,EAAMe,GACxBhf,CACR,CACH,CAcAqX,eAAeqK,eAAezD,GAC5B,OAAOA,EAAKoE,MAAM,oBAAqB9B,IACrC,MAAMiB,EAAEA,EAACC,EAAEA,EAACte,MAAEA,EAAKD,OAAEA,GAAWqd,EAAQ+B,wBACxC,MAAO,CACLd,IACAC,IACAte,QACAD,OAAQjF,KAAKskB,MAAMrf,EAAS,EAAIA,EAAS,KAC1C,GAEL,CAaAmU,eAAe6K,WAAWjE,GACxB,OAAOA,EAAKoE,MACV,gCACC9B,GAAYA,EAAQiC,WAEzB,CAkBAnL,eAAe8K,aAAalE,EAAM7iB,EAAMqnB,EAAM7e,GAC5C,OAAO6T,QAAQiL,KAAK,CAClBzE,EAAK0E,WAAW,CACdvnB,OACAqnB,OACAG,SAAU,SACVC,UAAU,EACVC,kBAAkB,EAClBC,uBAAuB,KACV,QAAT3nB,EAAiB,CAAE4nB,QAAS,IAAO,CAAA,EAEvCC,eAAwB,OAAR7nB,IAElB,IAAIqc,SAAQ,CAACyL,EAAUvL,IACrBgG,YACE,IAAMhG,EAAO,IAAIlE,YAAY,wBAAyB,OACtD7P,GAAwB,SAIhC,CAiBAyT,eAAe+K,WAAWnE,EAAM/a,EAAQC,EAAOS,GAE7C,aADMqa,EAAKkF,iBAAiB,UACrBlF,EAAKmF,IAAI,CAEdlgB,OAAQA,EAAS,EACjBC,QACAyf,SAAU,SACVje,QAASf,GAAwB,MAErC,CCnQA,IAAI0B,KAAO,KAGX,MAAM+d,UAAY,CAChBC,iBAAkB,EAClBC,iBAAkB,EAClBC,eAAgB,EAChBC,eAAgB,EAChBC,mBAAoB,EACpBC,uBAAwB,EACxBC,2BAA4B,EAC5BC,UAAW,EACXC,iBAAkB,GAqBbzM,eAAe0M,SAASC,EAAalH,SAEpCD,cAAcC,GAEpB,IAME,GALA1d,IACE,EACA,8CAA8C4kB,EAAYze,mBAAmBye,EAAYxe,eAGvFF,KAKF,YAJAlG,IACE,EACA,yEAMA4kB,EAAYze,WAAaye,EAAYxe,aACvCwe,EAAYze,WAAaye,EAAYxe,YAIvCF,KAAO,IAAI2e,KAAAA,KAAK,IAEXC,SAASF,GACZxgB,IAAKwgB,EAAYze,WACjB9B,IAAKugB,EAAYxe,WACjB2e,qBAAsBH,EAAYte,eAClC0e,oBAAqBJ,EAAYre,cACjC0e,qBAAsBL,EAAYpe,eAClC0e,kBAAmBN,EAAYne,YAC/B0e,0BAA2BP,EAAYle,oBACvC0e,mBAAoBR,EAAYje,eAChC0e,sBAAsB,IAIxBnf,KAAK0S,GAAG,WAAWX,MAAOwI,IAExB,MAAM6E,QAAoBpG,UAAUuB,GAAU,GAC9CzgB,IACE,EACA,yBAAyBygB,EAAShB,gDAAgD6F,KACnF,IAGHpf,KAAK0S,GAAG,kBAAkB,CAAC2M,EAAU9E,KACnCzgB,IACE,EACA,yBAAyBygB,EAAShB,0CAEpCgB,EAAS5B,KAAO,IAAI,IAGtB,MAAM2G,EAAmB,GAEzB,IAAK,IAAIzN,EAAI,EAAGA,EAAI6M,EAAYze,WAAY4R,IAC1C,IACE,MAAM0I,QAAiBva,KAAKuf,UAAUC,QACtCF,EAAiBtkB,KAAKuf,EACvB,CAAC,MAAO7f,GACPD,aAAa,EAAGC,EAAO,+CACxB,CAIH4kB,EAAiBtd,SAASuY,IACxBva,KAAKyf,QAAQlF,EAAS,IAGxBzgB,IACE,EACA,4BAA2BwlB,EAAiB1nB,OAAS,SAAS0nB,EAAiB1nB,oCAAsC,KAExH,CAAC,MAAO8C,GACP,MAAM,IAAIyT,YACR,6DACA,KACAM,SAAS/T,EACZ,CACH,CAYOqX,eAAe2N,WAIpB,GAHA5lB,IAAI,EAAG,6DAGHkG,KAAM,CAER,IAAK,MAAM2f,KAAU3f,KAAK4f,KACxB5f,KAAKyf,QAAQE,EAAOpF,UAIjBva,KAAK6f,kBACF7f,KAAK4a,UACX9gB,IAAI,EAAG,4CAETkG,KAAO,IACR,OAGKsY,cACR,CAmBOvG,eAAe+N,SAASziB,GAC7B,IAAI0iB,EAEJ,IAYE,GAXAjmB,IAAI,EAAG,gDAGLikB,UAAUC,iBAGR3gB,EAAQ2C,KAAKb,cACf6gB,eAIGhgB,KACH,MAAM,IAAImO,YACR,uDACA,KAKJ,MAAM8R,EAAiBhoB,cAGvB,IACE6B,IAAI,EAAG,qCAGPimB,QAAqB/f,KAAKuf,UAAUC,QAGhCniB,EAAQyB,OAAOK,cACjBrF,IACE,EACA,gBAAeuD,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,IACzE,kCAAkC0Z,SAGvC,CAAC,MAAOvlB,GACP,MAAM,IAAIyT,YACR,UACE9Q,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,0DACJ0Z,SACxD,KACAxR,SAAS/T,EACZ,CAGD,GAFAZ,IAAI,EAAG,qCAEFimB,EAAapH,KAGhB,MADAoH,EAAavG,UAAYnc,EAAQ2C,KAAKG,UAAY,EAC5C,IAAIgO,YACR,mEACA,KAKJ,MAAM+R,EAAY5oB,iBAElBwC,IACE,EACA,yBAAyBimB,EAAaxG,2CAIxC,MAAM4G,EAAgBloB,cAGhBwkB,QAAenB,gBACnByE,EAAapH,KACbtb,EAAQH,OACRG,EAAQkB,aAIV,GAAIke,aAAkBrO,MAmBpB,KANuB,0BAAnBqO,EAAO5hB,UAETklB,EAAavG,UAAYnc,EAAQ2C,KAAKG,UAAY,EAClD4f,EAAapH,KAAO,MAIJ,iBAAhB8D,EAAO/N,MACY,0BAAnB+N,EAAO5hB,QAED,IAAIsT,YACR,UACE9Q,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,mHAE5DkI,SAASgO,GAEL,IAAItO,YACR,UACE9Q,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,sCACxB4Z,UACpC1R,SAASgO,GAKXpf,EAAQyB,OAAOK,cACjBrF,IACE,EACA,gBAAeuD,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,IACzE,sCAAsC4Z,UAK1CngB,KAAKyf,QAAQM,GAIb,MACMK,EADU9oB,iBACa4oB,EAS7B,OAPAnC,UAAUQ,WAAa6B,EACvBrC,UAAUS,iBACRT,UAAUQ,YAAcR,UAAUE,iBAEpCnkB,IAAI,EAAG,4BAA4BsmB,QAG5B,CACL3D,SACApf,UAEH,CAAC,MAAO3C,GAOP,OANEqjB,UAAUG,eAER6B,GACF/f,KAAKyf,QAAQM,GAGTrlB,CACP,CACH,CAqBO,SAAS2lB,eACd,OAAOtC,SACT,CAUO,SAASuC,kBACd,MAAO,CACLpiB,IAAK8B,KAAK9B,IACVC,IAAK6B,KAAK7B,IACVyhB,KAAM5f,KAAKugB,UACXC,UAAWxgB,KAAKygB,UAChBC,WAAY1gB,KAAKugB,UAAYvgB,KAAKygB,UAClCE,gBAAiB3gB,KAAK4gB,qBACtBC,eAAgB7gB,KAAK8gB,oBACrBC,mBAAoB/gB,KAAKghB,wBACzBC,gBAAiBjhB,KAAKihB,gBAAgBrpB,OACtCspB,YACElhB,KAAKugB,UACLvgB,KAAKygB,UACLzgB,KAAK4gB,qBACL5gB,KAAK8gB,oBACL9gB,KAAKghB,wBACLhhB,KAAKihB,gBAAgBrpB,OAE3B,CASO,SAASooB,cACd,MAAM9hB,IACJA,EAAGC,IACHA,EAAGyhB,KACHA,EAAIY,UACJA,EAASE,WACTA,EAAUC,gBACVA,EAAeE,eACfA,EAAcE,mBACdA,EAAkBE,gBAClBA,EAAeC,YACfA,GACEZ,kBAEJxmB,IAAI,EAAG,2DAA2DoE,MAClEpE,IAAI,EAAG,2DAA2DqE,MAClErE,IAAI,EAAG,wCAAwC8lB,MAC/C9lB,IAAI,EAAG,wCAAwC0mB,MAC/C1mB,IACE,EACA,+DAA+D4mB,MAEjE5mB,IACE,EACA,0DAA0D6mB,MAE5D7mB,IACE,EACA,yDAAyD+mB,MAE3D/mB,IACE,EACA,2DAA2DinB,MAE7DjnB,IACE,EACA,2DAA2DmnB,MAE7DnnB,IAAI,EAAG,uCAAuConB,KAChD,CAWA,SAAStC,SAASF,GAChB,MAAO,CAcLyC,OAAQpP,UAEN,MAAM2G,EAAe,CACnBa,GAAI/S,KAAAA,KAEJgT,UAAW7gB,KAAKE,MAAMF,KAAKyoB,UAAY1C,EAAYve,UAAY,KAGjE,IAEE,MAAMkhB,EAAY/pB,iBAclB,aAXMmhB,QAAQC,GAGd5e,IACE,EACA,yBAAyB4e,EAAaa,6CACpCjiB,iBAAmB+pB,QAKhB3I,CACR,CAAC,MAAOhe,GAKP,MAJAZ,IACE,EACA,yBAAyB4e,EAAaa,qDAElC7e,CACP,GAgBH4mB,SAAUvP,MAAO2G,GAiBVA,EAAaC,KASdD,EAAaC,KAAKI,YACpBjf,IACE,EACA,yBAAyB4e,EAAaa,yDAEjC,GAILb,EAAaC,KAAK4I,YAAYC,UAChC1nB,IACE,EACA,yBAAyB4e,EAAaa,wDAEjC,KAKPmF,EAAYve,aACVuY,EAAac,UAAYkF,EAAYve,aAEvCrG,IACE,EACA,yBAAyB4e,EAAaa,yCAAyCmF,EAAYve,yCAEtF,IAlCPrG,IACE,EACA,yBAAyB4e,EAAaa,sDAEjC,GA8CXqB,QAAS7I,MAAO2G,IAMd,GALA5e,IACE,EACA,yBAAyB4e,EAAaa,8BAGpCb,EAAaC,OAASD,EAAaC,KAAKI,WAC1C,IAEEL,EAAaC,KAAK8I,mBAAmB,aACrC/I,EAAaC,KAAK8I,mBAAmB,WACrC/I,EAAaC,KAAK8I,mBAAmB,uBAG/B/I,EAAaC,KAAKH,OACzB,CAAC,MAAO9d,GAKP,MAJAZ,IACE,EACA,yBAAyB4e,EAAaa,mDAElC7e,CACP,CACF,EAGP,CCxkBO,SAASgnB,SAAS3qB,GAEvB,MAAMyI,EAAS,IAAImiB,MAAAA,MAAM,IAAIniB,OAM7B,OAHeoiB,UAAUpiB,GAGXkiB,SAAS3qB,EAAO,CAAE8qB,SAAU,CAAC,kBAC7C,CCMA,IAAIrjB,oBAAqB,EAqBlBuT,eAAe+P,aAAazkB,GAEjC,IAAIA,IAAWA,EAAQH,OA2CrB,MAAM,IAAIiR,YACR,kKACA,KA3CF9Q,EAAU+S,gBAAgB/S,SAGpB0kB,YACJ,CAAE7kB,OAAQG,EAAQH,OAAQqB,YAAalB,EAAQkB,cAC/CwT,MAAOrX,EAAOqT,KAEZ,GAAIrT,EACF,MAAMA,EAIR,MAAMgD,IAAEA,EAAG3H,QAAEA,EAAOD,KAAEA,GAASiY,EAAK1Q,QAAQH,OAG5C,IACMQ,EAEFqX,GAAaA,cACX,GAAGhf,EAAQE,MAAM,KAAKC,SAAW,cACjCY,UAAUiX,EAAK0O,OAAQ3mB,IAIzBif,GAAaA,cACXhf,GAAW,SAASD,IACX,QAATA,EAAiBkB,OAAOC,KAAK8W,EAAK0O,OAAQ,UAAY1O,EAAK0O,OAGhE,CAAC,MAAO/hB,GACP,MAAM,IAAIyT,YACR,sCACA,KACAM,SAAS/T,EACZ,OAGKglB,UAAU,GASxB,CAsBO3N,eAAeiQ,YAAY3kB,GAEhC,KAAIA,GAAWA,EAAQH,QAAUG,EAAQH,OAAOK,OA+E9C,MAAM,IAAI4Q,YACR,+GACA,KAjFmD,CAErD9Q,EAAU+S,gBAAgB/S,GAG1B,MAAM4kB,EAAiB,GAGvB,IAAK,IAAIC,KAAQ7kB,EAAQH,OAAOK,MAAMtH,MAAM,MAAQ,GAClDisB,EAAOA,EAAKjsB,MAAM,KACE,IAAhBisB,EAAKtqB,OACPqqB,EAAejnB,KACb+mB,YACE,CACE7kB,OAAQ,IACHG,EAAQH,OACXC,OAAQ+kB,EAAK,GACbnsB,QAASmsB,EAAK,IAEhB3jB,YAAalB,EAAQkB,cAEvB,CAAC7D,EAAOqT,KAEN,GAAIrT,EACF,MAAMA,EAIR,MAAMgD,IAAEA,EAAG3H,QAAEA,EAAOD,KAAEA,GAASiY,EAAK1Q,QAAQH,OAG5C,IACMQ,EAEFqX,GAAaA,cACX,GAAGhf,EAAQE,MAAM,KAAKC,SAAW,cACjCY,UAAUiX,EAAK0O,OAAQ3mB,IAIzBif,GAAaA,cACXhf,EACS,QAATD,EACIkB,OAAOC,KAAK8W,EAAK0O,OAAQ,UACzB1O,EAAK0O,OAGd,CAAC,MAAO/hB,GACP,MAAM,IAAIyT,YACR,sCACA,KACAM,SAAS/T,EACZ,MAKPZ,IAAI,EAAG,uDAKX,MAAMqoB,QAAqBhQ,QAAQiQ,WAAWH,SAGxCvC,WAGNyC,EAAangB,SAAQ,CAACya,EAAQvO,KAExBuO,EAAO4F,QACT5nB,aACE,EACAgiB,EAAO4F,OACP,+BAA+BnU,EAAQ,sCAE1C,GAEP,CAMA,CAoCO6D,eAAegQ,YAAYO,EAAkBC,GAClD,IAEE,IAAK/qB,SAAS8qB,GACZ,MAAM,IAAInU,YACR,qFACA,KAKJ,MAAM9Q,EAAUmS,aAAa3a,SAASga,cAAe,CACnD3R,OAAQolB,EAAiBplB,OACzBqB,YAAa+jB,EAAiB/jB,cAI1BqX,EAAgBvY,EAAQH,OAM9B,GAHApD,IAAI,EAAG,2CAGsB,OAAzB8b,EAAczY,OAAiB,CAGjC,IAAIqlB,EAFJ1oB,IAAI,EAAG,mDAGP,IAEE0oB,EAAcrpB,GAAYA,aACxBnD,gBAAgB4f,EAAczY,QAC9B,OAEH,CAAC,MAAOzC,GACP,MAAM,IAAIyT,YACR,mDACA,KACAM,SAAS/T,EACZ,CAGD,GAAIkb,EAAczY,OAAOjE,SAAS,QAEhC0c,EAActY,IAAM4S,eAAe,MAAOsS,OACrC,KAAI5M,EAAczY,OAAOjE,SAAS,SAIvC,MAAM,IAAIiV,YACR,kDACA,KAJFyH,EAAcxY,MAAQ8S,eAAe,QAASsS,EAM/C,CACF,CAGD,GAA0B,OAAtB5M,EAActY,IAAc,CAC9BxD,IAAI,EAAG,qDAGLumB,eAAehC,uBAGjB,MAAM5B,QAAegG,eACnBf,SAAS9L,EAActY,KACvBD,GAOF,QAHEgjB,eAAelC,eAGVoE,EAAY,KAAM9F,EAC1B,CAGD,GAA4B,OAAxB7G,EAAcxY,OAA4C,OAA1BwY,EAAcvY,QAAkB,CAClEvD,IAAI,EAAG,sDAGLumB,eAAe/B,2BAGjB,MAAM7B,QAAeiG,mBACnB9M,EAAcxY,OAASwY,EAAcvY,QACrCA,GAOF,QAHEgjB,eAAejC,mBAGVmE,EAAY,KAAM9F,EAC1B,CAGD,OAAO8F,EACL,IAAIpU,YACF,gJACA,KAGL,CAAC,MAAOzT,GACP,OAAO6nB,EAAY7nB,EACpB,CACH,CASO,SAASioB,wBACd,OAAOnkB,kBACT,CAUO,SAASokB,sBAAsBpqB,GACpCgG,mBAAqBhG,CACvB,CAkBAuZ,eAAe0Q,eAAeI,EAAexlB,GAE3C,GAC2B,iBAAlBwlB,IACNA,EAActe,QAAQ,SAAW,GAAKse,EAActe,QAAQ,UAAY,GAYzE,OAVAzK,IAAI,EAAG,iCAGPuD,EAAQH,OAAOI,IAAMulB,EAGrBxlB,EAAQH,OAAOE,MAAQ,KACvBC,EAAQH,OAAOG,QAAU,KAGlBylB,eAAezlB,GAEtB,MAAM,IAAI8Q,YAAY,mCAAoC,IAE9D,CAkBA4D,eAAe2Q,mBAAmBG,EAAexlB,GAC/CvD,IAAI,EAAG,uCAGP,MAAM4W,EAAqBL,gBACzBwS,GACA,EACAxlB,EAAQkB,YAAYC,oBAItB,GACyB,OAAvBkS,GAC8B,iBAAvBA,IACNA,EAAmBtX,WAAW,OAC9BsX,EAAmBxX,SAAS,KAE7B,MAAM,IAAIiV,YACR,oPACA,KAWJ,OANA9Q,EAAQH,OAAOE,MAAQsT,EAGvBrT,EAAQH,OAAOI,IAAM,KAGdwlB,eAAezlB,EACxB,CAcA0U,eAAe+Q,eAAezlB,GAC5B,MAAQH,OAAQ0Y,EAAerX,YAAaiT,GAAuBnU,EAkCnE,OA/BAuY,EAAc9f,KAAOK,QAAQyf,EAAc9f,KAAM8f,EAAc7f,SAG/D6f,EAAc7f,QAAUF,WAAW+f,EAAc9f,KAAM8f,EAAc7f,SAGrE6f,EAAcpgB,OAASD,UAAUqgB,EAAcpgB,QAG/CsE,IACE,EACA,+BAA+B0X,EAAmBhT,mBAAqB,UAAY,iBAIrFukB,mBAAmBvR,EAAoBA,EAAmBhT,oBAG1DwkB,sBACEpN,EACApE,EAAmBxY,mBACnBwY,EAAmBhT,oBAIrBnB,EAAQH,OAAS,IACZ0Y,KACAqN,eAAerN,IAIbkK,SAASziB,EAClB,CAqBA,SAAS4lB,eAAerN,GAEtB,MAAQoB,MAAOkM,EAAc5M,UAAW6M,GACtCvN,EAAcvY,SAAWgT,gBAAgBuF,EAAcxY,SAAU,GAG3D4Z,MAAOoM,EAAoB9M,UAAW+M,GAC5ChT,gBAAgBuF,EAAcxX,iBAAkB,GAG1C4Y,MAAOsM,EAAmBhN,UAAWiN,GAC3ClT,gBAAgBuF,EAAcvX,gBAAiB,EAM3CP,EAAQvF,YACZI,KAAKwF,IACH,GACAxF,KAAKuF,IACH0X,EAAc9X,OACZqlB,GAAkBrlB,OAClBulB,GAAwBvlB,OACxBylB,GAAuBzlB,OACvB8X,EAAc3X,cACd,EACF,IAGJ,GA4BIud,EAAO,CAAE5d,OAvBbgY,EAAchY,QACdulB,GAAkBK,cAClBN,GAActlB,QACdylB,GAAwBG,cACxBJ,GAAoBxlB,QACpB2lB,GAAuBC,cACvBF,GAAmB1lB,QACnBgY,EAAc7X,eACd,IAeqBF,MAXrB+X,EAAc/X,OACdslB,GAAkBM,aAClBP,GAAcrlB,OACdwlB,GAAwBI,aACxBL,GAAoBvlB,OACpB0lB,GAAuBE,aACvBH,GAAmBzlB,OACnB+X,EAAc5X,cACd,IAG4BF,SAG9B,IAAK,IAAK4lB,EAAOlrB,KAAUrD,OAAOwa,QAAQ6L,GACxCA,EAAKkI,GACc,iBAAVlrB,GAAsBA,EAAM7C,QAAQ,SAAU,IAAM6C,EAI/D,OAAOgjB,CACT,CAkBA,SAASuH,mBAAmBvR,EAAoBhT,GAE9C,GAAIA,EAAoB,CAEtB,GAA4C,iBAAjCgT,EAAmB9S,UAE5B8S,EAAmB9S,UAAYilB,iBAC7BnS,EAAmB9S,UACnB8S,EAAmBxY,oBACnB,QAEG,IAAKwY,EAAmB9S,UAC7B,IAEE8S,EAAmB9S,UAAYilB,iBAC7BxqB,GAAAA,aAAanD,gBAAgB,kBAAmB,QAChDwb,EAAmBxY,oBACnB,EAEH,CAAC,MAAO0B,GACPZ,IAAI,EAAG,4DACR,CAIH,IAEE0X,EAAmBzY,WAAaD,WAC9B0Y,EAAmBzY,WACnByY,EAAmBxY,oBAIrBwY,EAAmBzY,WAAamX,eAC9B,aACAsB,EAAmBzY,WAEtB,CAAC,MAAO2B,GACPD,aAAa,EAAGC,EAAO,8CAGvB8W,EAAmBzY,WAAa,IACjC,CAGD,IAEEyY,EAAmB/S,SAAW3F,WAC5B0Y,EAAmB/S,SACnB+S,EAAmBxY,oBACnB,GAIFwY,EAAmB/S,SAAWyR,eAC5B,WACAsB,EAAmB/S,SAEtB,CAAC,MAAO/D,GACPD,aAAa,EAAGC,EAAO,4CAGvB8W,EAAmB/S,SAAW,IAC/B,CAGG,CAAC,UAAMlE,GAAW3E,SAAS4b,EAAmBzY,aAChDe,IAAI,EAAG,uDAIL,CAAC,UAAMS,GAAW3E,SAAS4b,EAAmB/S,WAChD3E,IAAI,EAAG,qDAIL,CAAC,UAAMS,GAAW3E,SAAS4b,EAAmB9S,YAChD5E,IAAI,EAAG,qDAEb,MAII,GACE0X,EAAmB/S,UACnB+S,EAAmB9S,WACnB8S,EAAmBzY,WAQnB,MALAyY,EAAmB/S,SAAW,KAC9B+S,EAAmB9S,UAAY,KAC/B8S,EAAmBzY,WAAa,KAG1B,IAAIoV,YACR,oGACA,IAIR,CAkBA,SAASwV,iBACPjlB,EAAY,KACZ1F,EACAwF,GAGA,MAAMolB,EAAe,CAAC,KAAM,MAAO,SAEnC,IAAIC,EAAmBnlB,EACnBolB,GAAmB,EAGvB,GAAI9qB,GAAsB0F,EAAUxF,SAAS,SAC3C,IACE2qB,EAAmBxT,gBACjBlX,GAAAA,aAAanD,gBAAgB0I,GAAY,SACzC,EACAF,EAER,CAAM,MACA,OAAO,IACR,MAGDqlB,EAAmBxT,gBAAgB3R,GAAW,EAAOF,GAGjDqlB,IAAqB7qB,UAChB6qB,EAAiB/e,MAK5B,IAAK,MAAMif,KAAYF,EAChBD,EAAahuB,SAASmuB,GAEfD,IACVA,GAAmB,UAFZD,EAAiBE,GAO5B,OAAKD,GAKDD,EAAiB/e,QACnB+e,EAAiB/e,MAAQ+e,EAAiB/e,MAAM3J,KAAK1D,GAASA,EAAKJ,WAC9DwsB,EAAiB/e,OAAS+e,EAAiB/e,MAAMlN,QAAU,WACvDisB,EAAiB/e,OAK5B+e,EAAmB3T,eAAe,YAAa2T,GAGxCA,GAfE,IAgBX,CAoBA,SAASb,sBACPpN,EACA5c,EACAwF,GAGA,CAAC,gBAAiB,gBAAgBwD,SAASgiB,IACzC,IAEMpO,EAAcoO,KAGdhrB,GACsC,iBAA/B4c,EAAcoO,IACrBpO,EAAcoO,GAAa9qB,SAAS,SAGpC0c,EAAcoO,GAAe3T,gBAC3BlX,GAAAA,aAAanD,gBAAgB4f,EAAcoO,IAAe,SAC1D,EACAxlB,GAIFoX,EAAcoO,GAAe3T,gBAC3BuF,EAAcoO,IACd,EACAxlB,GAKJoX,EAAcoO,GAAe9T,eAC3B8T,EACApO,EAAcoO,IAGnB,CAAC,MAAOtpB,GACPD,aACE,EACAC,EACA,iBAAiBspB,yBAInBpO,EAAcoO,GAAe,IAC9B,KAIC,CAAC,UAAMzpB,GAAW3E,SAASggB,EAAcxX,gBAC3CtE,IAAI,EAAG,0DAIL,CAAC,UAAMS,GAAW3E,SAASggB,EAAcvX,eAC3CvE,IAAI,EAAG,wDAEX,CCj2BA,MAAMmqB,SAAW,GASV,SAASC,SAAS3K,GACvB0K,SAASjpB,KAAKue,EAChB,CAQO,SAAS4K,iBACdrqB,IAAI,EAAG,2DACP,IAAK,MAAMyf,KAAM0K,SACfG,cAAc7K,GACd8K,aAAa9K,EAEjB,CCfA,SAAS+K,mBAAmB5pB,EAAO6pB,EAAS/R,EAAUgS,GAUpD,OARA/pB,aAAa,EAAGC,GAGmB,gBAA/BmU,aAAajO,MAAMC,gBACdnG,EAAMK,MAIRypB,EAAK9pB,EACd,CAYA,SAAS+pB,sBAAsB/pB,EAAO6pB,EAAS/R,EAAUgS,GAEvD,MAAM3pB,QAAEA,EAAOE,MAAEA,GAAUL,EAGrB4T,EAAa5T,EAAM4T,YAAc,IAGvCkE,EAASkS,OAAOpW,GAAYqW,KAAK,CAAErW,aAAYzT,UAASE,SAC1D,CAOe,SAAS6pB,gBAAgBC,GAEtCA,EAAIC,IAAIR,oBAGRO,EAAIC,IAAIL,sBACV,CC5Ce,SAASM,uBAAuBF,EAAKG,GAClD,IAEE,GAAIA,EAAoBjmB,OAAQ,CAC9B,MAAMlE,EACJ,yEAGIoqB,EAAc,CAClBzlB,OAAQwlB,EAAoBxlB,QAAU,EACtCD,YAAaylB,EAAoBzlB,aAAe,GAChDE,MAAOulB,EAAoBvlB,OAAS,EACpCC,WAAYslB,EAAoBtlB,aAAc,EAC9CC,QAASqlB,EAAoBrlB,SAAW,KACxCC,UAAWolB,EAAoBplB,WAAa,MAI1CqlB,EAAYvlB,YACdmlB,EAAI9lB,OAAO,eAIb,MAAMmmB,EAAUC,UAAU,CAExBC,SAA+B,GAArBH,EAAYzlB,OAAc,IAEpC6lB,MAAOJ,EAAY1lB,YAEnB+lB,QAASL,EAAYxlB,MACrB8lB,QAAS,CAAChB,EAAS/R,KACjBA,EAASgT,OAAO,CACdb,KAAM,KACJnS,EAASkS,OAAO,KAAKe,KAAK,CAAE5qB,WAAU,EAExC6qB,QAAS,KACPlT,EAASkS,OAAO,KAAKe,KAAK5qB,EAAQ,GAEpC,EAEJ8qB,KAAOpB,GAGqB,OAAxBU,EAAYtlB,SACc,OAA1BslB,EAAYrlB,WACZ2kB,EAAQqB,MAAM1wB,MAAQ+vB,EAAYtlB,SAClC4kB,EAAQqB,MAAMC,eAAiBZ,EAAYrlB,YAE3C9F,IAAI,EAAG,2CACA,KAOb+qB,EAAIC,IAAII,GAERprB,IACE,EACA,8CAA8CmrB,EAAY1lB,4BAA4B0lB,EAAYzlB,8CAA8CylB,EAAYvlB,cAE/J,CACF,CAAC,MAAOhF,GACP,MAAM,IAAIyT,YACR,yEACA,KACAM,SAAS/T,EACZ,CACH,CCzDA,SAASorB,sBAAsBvB,EAAS/R,EAAUgS,GAChD,IAEE,MAAMuB,EAAcxB,EAAQyB,QAAQ,iBAAmB,GAGvD,IACGD,EAAYnwB,SAAS,sBACrBmwB,EAAYnwB,SAAS,uCACrBmwB,EAAYnwB,SAAS,uBAEtB,MAAM,IAAIuY,YACR,iHACA,KAKJ,OAAOqW,GACR,CAAC,MAAO9pB,GACP,OAAO8pB,EAAK9pB,EACb,CACH,CAmBA,SAASurB,sBAAsB1B,EAAS/R,EAAUgS,GAChD,IAEE,MAAMnL,EAAOkL,EAAQlL,KAGf9S,EAAYC,KAAAA,KAGlB,IAAK6S,GAAQ3hB,cAAc2hB,GAQzB,MAPAvf,IACE,EACA,yBAAyByM,yBACvBge,EAAQyB,QAAQ,oBAAsBzB,EAAQ2B,WAAWC,2DAIvD,IAAIhY,YACR,yBAAyB5H,8JACzB,KAKJ,MAAM/H,EAAqBmkB,wBAGrBvlB,EAAQiT,gBAEZgJ,EAAKjc,OAASic,EAAKhc,SAAWgc,EAAKlc,QAAUkc,EAAKtL,MAElD,EAEAvP,GAIF,GAAc,OAAVpB,IAAmBic,EAAK/b,IAQ1B,MAPAxD,IACE,EACA,yBAAyByM,yBACvBge,EAAQyB,QAAQ,oBAAsBzB,EAAQ2B,WAAWC,2FACmB1V,KAAKa,UAAU+H,OAGzF,IAAIlL,YACR,YAAY5H,sRACZ,KAKJ,GAAI8S,EAAK/b,KAAOzF,uBAAuBwhB,EAAK/b,KAC1C,MAAM,IAAI6Q,YACR,YAAY5H,iMACZ,KA0CJ,OArCAge,EAAQ6B,iBAAmBhW,gBAAgB,CAEzC7J,YACArJ,OAAQ,CACNE,QACAE,IAAK+b,EAAK/b,IACVvH,QACEsjB,EAAKtjB,SACL,GAAGwuB,EAAQvhB,OAAOqjB,UAAY,WAAWhN,EAAKvjB,MAAQ,QACxDA,KAAMujB,EAAKvjB,KACXN,OAAQ6jB,EAAK7jB,OACbkI,IAAK2b,EAAK3b,IACVC,WAAY0b,EAAK1b,WACjBC,OAAQyb,EAAKzb,OACbC,MAAOwb,EAAKxb,MACZC,MAAOub,EAAKvb,MACZM,cAAeiS,gBACbgJ,EAAKjb,eACL,EACAI,GAEFH,aAAcgS,gBACZgJ,EAAKhb,cACL,EACAG,IAGJD,YAAa,CACXC,qBACAxF,oBAAoB,EACpBD,WAAYsgB,EAAKtgB,WACjB0F,SAAU4a,EAAK5a,SACfC,UAAW2R,gBAAgBgJ,EAAK3a,WAAW,EAAMF,MAK9CgmB,GACR,CAAC,MAAO9pB,GACP,OAAO8pB,EAAK9pB,EACb,CACH,CAOe,SAAS4rB,qBAAqBzB,GAE3CA,EAAI0B,KAAK,CAAC,IAAK,cAAeT,uBAG9BjB,EAAI0B,KAAK,CAAC,IAAK,cAAeN,sBAChC,CC7KA,MAAMO,aAAe,CACnBC,IAAK,YACLC,KAAM,aACNC,IAAK,YACL7I,IAAK,kBACLxgB,IAAK,iBAgBPyU,eAAe6U,cAAcrC,EAAS/R,EAAUgS,GAC9C,IAEE,MAAMqC,EAAiB5uB,cAGvB,IAAI6uB,GAAoB,EACxBvC,EAAQwC,OAAOrU,GAAG,SAAUsU,IACtBA,IACFF,GAAoB,EACrB,IAIH,MAAM5U,EAAiBqS,EAAQ6B,iBAGzB7f,EAAY2L,EAAe3L,UAGjCzM,IAAI,EAAG,qBAAqByM,4CAGtBwb,YAAY7P,GAAgB,CAACxX,EAAOqT,KAKxC,GAHAwW,EAAQwC,OAAOtF,mBAAmB,SAG9BqF,EACFhtB,IACE,EACA,qBAAqByM,mFAHzB,CASA,GAAI7L,EACF,MAAMA,EAIR,IAAKqT,IAASA,EAAK0O,OASjB,MARA3iB,IACE,EACA,qBAAqByM,qBACnBge,EAAQyB,QAAQ,oBAChBzB,EAAQ2B,WAAWC,mDACiBpY,EAAK0O,WAGvC,IAAItO,YACR,qBAAqB5H,yGACrB,KAKJ,GAAIwH,EAAK0O,OAAQ,CACf3iB,IACE,EACA,qBAAqByM,yCAAiDsgB,UAIxE,MAAM/wB,KAAEA,EAAI4H,IAAEA,EAAGC,WAAEA,EAAU5H,QAAEA,GAAYgY,EAAK1Q,QAAQH,OAGxD,OAAIQ,EACK8U,EAASiT,KAAK3uB,UAAUiX,EAAK0O,OAAQ3mB,KAI9C0c,EAASyU,OAAO,eAAgBT,aAAa1wB,IAAS,aAGjD6H,GACH6U,EAAS0U,WAAWnxB,GAIN,QAATD,EACH0c,EAASiT,KAAK1X,EAAK0O,QACnBjK,EAASiT,KAAKzuB,OAAOC,KAAK8W,EAAK0O,OAAQ,WAC5C,CAlDA,CAkDA,GAEJ,CAAC,MAAO/hB,GACP,OAAO8pB,EAAK9pB,EACb,CACH,CASe,SAASysB,aAAatC,GAKnCA,EAAI0B,KAAK,IAAKK,eAMd/B,EAAI0B,KAAK,aAAcK,cACzB,CCpIA,MAAMQ,gBAAkB,IAAIhwB,KAGtBiwB,YAAc5W,KAAKzD,MACvB7T,GAAAA,aAAatC,KAAAA,KAAK7C,YAAW,gBAAiB,SAI1CszB,aAAe,GAGfC,eAAiB,IAGjBC,WAAa,GAUnB,SAASC,0BACP,OAAOH,aAAavX,QAAO,CAAC2X,EAAGC,IAAMD,EAAIC,GAAG,GAAKL,aAAa1vB,MAChE,CAUA,SAASgwB,oBACP,OAAOC,aAAY,KACjB,MAAMC,EAAQzH,eACR0H,EACuB,IAA3BD,EAAM9J,iBACF,EACC8J,EAAM7J,iBAAmB6J,EAAM9J,iBAAoB,IAE1DsJ,aAAatsB,KAAK+sB,GACdT,aAAa1vB,OAAS4vB,YACxBF,aAAapxB,OACd,GACAqxB,eACL,CASe,SAASS,aAAanD,GAGnCX,SAAS0D,qBAKT/C,EAAItS,IAAI,WAAW,CAACgS,EAAS/R,EAAUgS,KACrC,IACE1qB,IAAI,EAAG,qCAEP,MAAMguB,EAAQzH,eACR4H,EAASX,aAAa1vB,OACtBswB,EAAgBT,0BAGtBjV,EAASiT,KAAK,CAEZf,OAAQ,KACRyD,SAAUf,gBACVgB,OAAQ,GAAGzvB,KAAK0vB,OAAO/wB,iBAAmB8vB,gBAAgB7vB,WAAa,IAAO,cAG9E+wB,cAAejB,YAAY5qB,QAC3B8rB,kBAAmBlU,uBAGnBmU,kBAAmBV,EAAMtJ,iBACzBiK,iBAAkBX,EAAM9J,iBACxB0K,iBAAkBZ,EAAM7J,iBACxB0K,cAAeb,EAAM5J,eACrB0K,YAAcd,EAAM7J,iBAAmB6J,EAAM9J,iBAAoB,IAGjEhe,KAAMsgB,kBAGN2H,SACAC,gBACArtB,QACEgJ,MAAMqkB,KAAmBZ,aAAa1vB,OAClC,oEACA,QAAQqwB,mCAAwCC,EAAcW,QAAQ,OAG5EC,WAAYhB,EAAM3J,eAClB4K,YAAajB,EAAM1J,mBACnB4K,mBAAoBlB,EAAMzJ,uBAC1B4K,oBAAqBnB,EAAMxJ,4BAE9B,CAAC,MAAO5jB,GACP,OAAO8pB,EAAK9pB,EACb,IAEL,CC9Ge,SAASwuB,SAASrE,GAI/BA,EAAItS,IAAI1D,aAAanO,GAAGC,OAAS,KAAK,CAAC4jB,EAAS/R,EAAUgS,KACxD,IACE1qB,IAAI,EAAG,qCAEP0Y,EAAS2W,SAAStyB,KAAIA,KAAC7C,YAAW,SAAU,cAAe,CACzDo1B,cAAc,GAEjB,CAAC,MAAO1uB,GACP,OAAO8pB,EAAK9pB,EACb,IAEL,CCde,SAAS2uB,oBAAoBxE,GAK1CA,EAAI0B,KAAK,+BAA+BxU,MAAOwS,EAAS/R,EAAUgS,KAChE,IACE1qB,IAAI,EAAG,0CAGP,MAAMwK,EAAayI,KAAKhF,uBAGxB,IAAKzD,IAAeA,EAAW1M,OAC7B,MAAM,IAAIuW,YACR,iHACA,KAKJ,MAAMmb,EAAQ/E,EAAQhS,IAAI,WAG1B,IAAK+W,GAASA,IAAUhlB,EACtB,MAAM,IAAI6J,YACR,2EACA,KAKJ,IAAIoG,EAAagQ,EAAQvhB,OAAOuR,WAGhC,IACEA,EAAarE,eAAe,UAAWqU,EAAQvhB,OAAOuR,WACvD,CAAC,MAAO7Z,GACP,MAAM,IAAIyT,YACR,mCAAmCzT,EAAMG,UACzC,KACA4T,SAAS/T,EACZ,CAGD,IAAI6Z,EAmBF,MAAM,IAAIpG,YAAY,qCAAsC,KAlB5D,UAEQmG,wBAAwBC,EAC/B,CAAC,MAAO7Z,GACP,MAAM,IAAIyT,YACR,6BAA6BzT,EAAMG,UACnC,KACA4T,SAAS/T,EACZ,CAGD8X,EAASkS,OAAO,KAAKe,KAAK,CACxBnX,WAAY,IACZia,kBAAmBlU,uBACnBxZ,QAAS,+CAA+C0Z,MAM7D,CAAC,MAAO7Z,GACP,OAAO8pB,EAAK9pB,EACb,IAEL,CCvDA,MAAM6uB,cAAgB,IAAIC,IAGpB3E,IAAM4E,UAsBL1X,eAAe2X,YAAYC,GAChC,IAEE,MAAMtsB,EAAUiS,cACdc,gBAAgB,CACdtR,OAAQ6qB,KAQZ,KAHAA,EAAgBtsB,EAAQyB,QAGLC,SAAW8lB,IAC5B,MAAM,IAAI1W,YACR,mFACA,KAMJ,MAAMyb,EAA+C,KAA5BD,EAAczqB,YAAqB,KAGtD2qB,EAAUC,OAAOC,gBAGjBC,EAASF,OAAO,CACpBD,UACAI,OAAQ,CACNC,UAAWN,KA2Cf,GAtCA/E,IAAIsF,QAAQ,gBAGZtF,IAAIC,IACFsF,KAAK,CACHC,QAAS,CAAC,OAAQ,MAAO,cAM7BxF,IAAIC,KAAI,CAACP,EAAS/R,EAAUgS,KAC1BhS,EAAS8X,IAAI,gBAAiB,QAC9B9F,GAAM,IAIRK,IAAIC,IACF2E,QAAQ9E,KAAK,CACXU,MAAOuE,KAKX/E,IAAIC,IACF2E,QAAQc,WAAW,CACjBC,UAAU,EACVnF,MAAOuE,KAKX/E,IAAIC,IAAIkF,EAAOS,QAGf5F,IAAIC,IAAI2E,QAAQiB,OAAO7zB,KAAIA,KAAC7C,YAAW,aAGlC21B,EAAc9pB,IAAIC,MAAO,CAE5B,MAAM6qB,EAAa7X,KAAK8X,aAAa/F,KAGrCgG,2BAA2BF,GAG3BA,EAAWG,OAAOnB,EAAc1qB,KAAM0qB,EAAc3qB,MAAM,KAExDuqB,cAAce,IAAIX,EAAc1qB,KAAM0rB,GAEtC7wB,IACE,EACA,mCAAmC6vB,EAAc3qB,QAAQ2qB,EAAc1qB,QACxE,GAEJ,CAGD,GAAI0qB,EAAc9pB,IAAId,OAAQ,CAE5B,IAAI7J,EAAK61B,EAET,IAEE71B,QAAY81B,SAAQA,SAClBn0B,KAAIA,KAACb,gBAAgB2zB,EAAc9pB,IAAIE,UAAW,cAClD,QAIFgrB,QAAaC,SAAQA,SACnBn0B,KAAIA,KAACb,gBAAgB2zB,EAAc9pB,IAAIE,UAAW,cAClD,OAEH,CAAC,MAAOrF,GACPZ,IACE,EACA,qDAAqD6vB,EAAc9pB,IAAIE,sDAE1E,CAED,GAAI7K,GAAO61B,EAAM,CAEf,MAAME,EAAcpY,MAAM+X,aAAa,CAAE11B,MAAK61B,QAAQlG,KAGtDgG,2BAA2BI,GAG3BA,EAAYH,OAAOnB,EAAc9pB,IAAIZ,KAAM0qB,EAAc3qB,MAAM,KAE7DuqB,cAAce,IAAIX,EAAc9pB,IAAIZ,KAAMgsB,GAE1CnxB,IACE,EACA,oCAAoC6vB,EAAc3qB,QAAQ2qB,EAAc9pB,IAAIZ,QAC7E,GAEJ,CACF,CAGD8lB,uBAAuBF,IAAK8E,EAAcrqB,cAG1CgnB,qBAAqBzB,KAGrBsC,aAAatC,KACbmD,aAAanD,KACbqE,SAASrE,KACTwE,oBAAoBxE,KAGpBD,gBAAgBC,IACjB,CAAC,MAAOnqB,GACP,MAAM,IAAIyT,YACR,qDACA,KACAM,SAAS/T,EACZ,CACH,CAOO,SAASwwB,eAEd,GAAI3B,cAAc/N,KAAO,EAAG,CAC1B1hB,IAAI,EAAG,iCAGP,IAAK,MAAOmF,EAAMH,KAAWyqB,cAC3BzqB,EAAO0Z,OAAM,KACX+Q,cAAc4B,OAAOlsB,GACrBnF,IAAI,EAAG,mCAAmCmF,KAAQ,GAGvD,CACH,CASO,SAASmsB,aACd,OAAO7B,aACT,CASO,SAAS8B,aACd,OAAO5B,OACT,CASO,SAAS6B,SACd,OAAOzG,GACT,CAYO,SAAStf,mBAAmByf,GAEjC,MAAM3nB,EAAUiS,cACdc,gBAAgB,CACdtR,OAAQ,CACNQ,aAAc0lB,MAMpBD,uBAAuBF,IAAKxnB,EAAQyB,OAAOkmB,oBAC7C,CAUO,SAASF,IAAInuB,KAAS40B,GAC3B1G,IAAIC,IAAInuB,KAAS40B,EACnB,CAUO,SAAShZ,IAAI5b,KAAS40B,GAC3B1G,IAAItS,IAAI5b,KAAS40B,EACnB,CAUO,SAAShF,KAAK5vB,KAAS40B,GAC5B1G,IAAI0B,KAAK5vB,KAAS40B,EACpB,CASA,SAASV,2BAA2B/rB,GAClCA,EAAO4T,GAAG,eAAe,CAAChY,EAAOqsB,KAC/BtsB,aACE,EACAC,EACA,0BAA0BA,EAAMG,+BAElCksB,EAAOnM,SAAS,IAGlB9b,EAAO4T,GAAG,SAAUhY,IAClBD,aAAa,EAAGC,EAAO,0BAA0BA,EAAMG,UAAU,IAGnEiE,EAAO4T,GAAG,cAAeqU,IACvBA,EAAOrU,GAAG,SAAUhY,IAClBD,aAAa,EAAGC,EAAO,0BAA0BA,EAAMG,UAAU,GACjE,GAEN,CAEA,IAAeiE,OAAA,CACb4qB,wBACAwB,0BACAE,sBACAC,sBACAC,cACA/lB,sCACAuf,QACAvS,QACAgU,WC3VKxU,eAAeyZ,gBAAgBC,EAAW,SAEzCtZ,QAAQiQ,WAAW,CAEvB+B,iBAGA+G,eAGAxL,aAIFvnB,QAAQuzB,KAAKD,EACf,CCkBO1Z,eAAe4Z,WAAWC,EAAc,IAE7C,MAAMvuB,EAAUiS,cAAcc,gBAAgBwb,IAAc,GAG5DhJ,sBAAsBvlB,EAAQkB,YAAYC,oBAG1CnD,YAAYgC,EAAQ/D,SAGhB+D,EAAQuD,MAAME,sBAChB+qB,oCAII1Y,oBAAoB9V,EAAQb,WAAYa,EAAQyB,OAAOM,aAGvDqf,SAASphB,EAAQ2C,KAAM3C,EAAQpB,UAAUlC,KACjD,CASA,SAAS8xB,8BACP/xB,IAAI,EAAG,sDAGP3B,QAAQua,GAAG,QAASlF,IAClB1T,IAAI,EAAG,sCAAsC0T,KAAQ,IAIvDrV,QAAQua,GAAG,UAAUX,MAAOrD,EAAMlB,KAChC1T,IAAI,EAAG,iBAAiB4U,sBAAyBlB,YAC3Cge,iBAAiB,IAIzBrzB,QAAQua,GAAG,WAAWX,MAAOrD,EAAMlB,KACjC1T,IAAI,EAAG,iBAAiB4U,sBAAyBlB,YAC3Cge,iBAAiB,IAIzBrzB,QAAQua,GAAG,UAAUX,MAAOrD,EAAMlB,KAChC1T,IAAI,EAAG,iBAAiB4U,sBAAyBlB,YAC3Cge,iBAAiB,IAIzBrzB,QAAQua,GAAG,qBAAqBX,MAAOrX,EAAOgU,KAC5CjU,aAAa,EAAGC,EAAO,iBAAiBgU,kBAClC8c,gBAAgB,EAAE,GAE5B,CAEA,IAAetd,MAAA,IAEVpP,OAGH+P,sBACAE,kCACAa,gCAGAM,8BACAE,gCAGAub,sBACA7J,0BACAE,wBACAD,wBAGArC,kBACA8L,gCAGA1xB,QACAW,0BACAQ,0BACAQ,YAAa,SAAUvB,GAWrBuB,YATgB6T,cACdc,gBAAgB,CACd9W,QAAS,CACPY,YAMcZ,QAAQY,MAC7B,EACDwB,qBAAsB,SAAUnC,GAW9BmC,qBATgB4T,cACdc,gBAAgB,CACd9W,QAAS,CACPC,gBAMuBD,QAAQC,UACtC,EACDoC,kBAAmB,SAAUJ,EAAMC,EAAMhC,GAEvC,MAAM6D,EAAUiS,cACdc,gBAAgB,CACd9W,QAAS,CACPiC,OACAC,OACAhC,aAMNmC,kBACE0B,EAAQ/D,QAAQiC,KAChB8B,EAAQ/D,QAAQkC,KAChB6B,EAAQ/D,QAAQE,OAEnB"} diff --git a/dist/index.esm.js.map b/dist/index.esm.js.map index dd3f1f3e..ce7aeed8 100644 --- a/dist/index.esm.js.map +++ b/dist/index.esm.js.map @@ -1 +1 @@ -{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || '';\r\n logging.file = file || '';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n // Object for options loaded via the `loadConfig` option\r\n let configOptions = {};\r\n\r\n // Object for options from the CLI\r\n let cliOptions = {};\r\n\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Validate options from the custom JSON loaded via the `loadConfig`\r\n configOptions = strictValidate(\r\n _loadConfigFile(cliArgs, globalOptions.customLogic)\r\n );\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options from the `loadConfig` option validation error'\r\n );\r\n }\r\n\r\n try {\r\n // Validate options from the CLI\r\n cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] CLI options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Apply custom options if there are any\r\n if (\r\n customOptions &&\r\n isObject(customOptions) &&\r\n Object.keys(customOptions).length\r\n ) {\r\n try {\r\n // Validate custom options provided by the user\r\n customOptions = strictValidate(customOptions);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Update values of the global options with values from each source possible\r\n _updateGlobalOptions(\r\n defaultConfig,\r\n globalOptions,\r\n configOptions,\r\n cliOptions,\r\n customOptions\r\n );\r\n\r\n // Return updated global options\r\n return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n // Check if options need to be created for a new instance\r\n if (newInstance) {\r\n // Get rid of the old instance options\r\n Object.keys(instanceOptions).forEach((key) => {\r\n delete instanceOptions[key];\r\n });\r\n\r\n // Init the new instance options based on the global options\r\n mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n }\r\n\r\n // Merge additional options to the instance options\r\n mergeOptions(instanceOptions, updateOptions);\r\n\r\n // Return the reference to the instance options object\r\n return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty array.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n .bold.yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[item.envLink];\r\n if (envVal !== undefined && envVal !== null) {\r\n options[name] = envVal;\r\n } else {\r\n options[name] = item.value;\r\n }\r\n } else {\r\n options[name] = _initGlobalOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the config entry of a specific option\r\n const entry = config[key];\r\n\r\n // Gather values for the options from every possible source, if exists\r\n const configVal = configOpt && configOpt[key];\r\n const cliVal = cliOpt && cliOpt[key];\r\n const customVal = customOpt && customOpt[key];\r\n\r\n // If the value not found, need to go deeper\r\n if (typeof entry.value === 'undefined') {\r\n _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n } else {\r\n // If a value from custom JSON options exists, it takes precedence\r\n if (configVal !== undefined && configVal !== null) {\r\n options[key] = configVal;\r\n }\r\n\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[entry.envLink];\r\n if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n options[key] = envVal;\r\n }\r\n\r\n // If a value from CLI options exists, it takes precedence\r\n if (cliVal !== undefined && cliVal !== null) {\r\n options[key] = cliVal;\r\n }\r\n\r\n // If a value from user options exists, it takes precedence\r\n if (customVal !== undefined && customVal !== null) {\r\n options[key] = customVal;\r\n }\r\n }\r\n });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n // Check if the `loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `loadConfig` is present and has a correct value\r\n if (configFileName && customLogicOptions.allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n setGlobalOptions,\r\n updateOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Get the reference to the global options to update to the new version\r\n const options = getOptions();\r\n\r\n // Set to the new version\r\n options.highcharts.version = newVersion;\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: join(__dirname, cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { createBrowser, closeBrowser, newPage, clearPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const result = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n getOptions,\r\n isAllowedConfig,\r\n mergeOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n deepCopy,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n isObject,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Validate single export options\r\n options = validateOptions(options);\r\n\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // Validate batch export options\r\n options = validateOptions(options);\r\n\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n try {\r\n // Check if provided options is an object\r\n if (!isObject(exportingOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = mergeOptions(deepCopy(getOptions()), {\r\n export: exportingOptions.export,\r\n customLogic: exportingOptions.customLogic\r\n });\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Validate option\r\n handledResources = validateOption('resources', handledResources);\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled\r\n if (rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log, logZodIssues } from '../../logger.js';\r\nimport {\r\n fixConstr,\r\n fixType,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound\r\n} from '../../utils.js';\r\nimport { looseValidate } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Validate the request options and store parsed structure in the request\r\n request.validatedOptions = validateOptions({\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n });\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolStats, getPoolInfoJSON } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n let newVersion = request.params.newVersion;\r\n\r\n // Validate the version\r\n try {\r\n newVersion = validateOption('version', request.params.newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version is incorrect: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // When a correct value found\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: serverOptions\r\n })\r\n );\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n })\r\n );\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n // Init, validate and update the instance options object\r\n const options = updateOptions(validateOptions(initOptions), true);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n level\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","customLogicOptions","configIndex","findIndex","arg","configFileName","i","option","async","fetch","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"0kBA2BO,MAAMA,UAAYC,cAAc,IAAIC,IAAI,mBAAoBC,MA+B5D,SAASC,SAASC,GAEvB,GAAe,OAAXA,GAAqC,iBAAXA,EAC5B,OAAOA,EAIT,MAAMC,EAAaC,MAAMC,QAAQH,GAAU,GAAK,GAGhD,IAAK,MAAMI,KAAOJ,EACZK,OAAOC,UAAUC,eAAeC,KAAKR,EAAQI,KAC/CH,EAAWG,GAAOL,SAASC,EAAOI,KAKtC,OAAOH,CACT,CA2DO,SAASQ,UAAUC,GACxB,IAEE,MAAMC,EAAc,GAAGD,EAAOE,cAAcC,QAAQ,QAAS,WAQ7D,MALoB,UAAhBF,GACFA,EAAYC,cAIP,CAAC,QAAS,aAAc,WAAY,cAAcE,SACvDH,GAEEA,EACA,OACR,CAAI,MAEA,MAAO,OACR,CACH,CAYO,SAASI,WAAWC,EAAMC,GAO/B,MAAO,GALUC,gBAAgBD,GAAW,SACzCE,MAAM,KACNC,WAGmBJ,GACxB,CAaO,SAASK,QAAQL,EAAMC,EAAU,MAEtC,MAAMK,EAAY,CAChB,YAAa,MACb,aAAc,OACd,kBAAmB,MACnB,gBAAiB,OAIbC,EAAUlB,OAAOmB,OAAOF,GAG9B,GAAIL,EAAS,CACX,MAAMQ,EAAUR,EAAQE,MAAM,KAAKO,MAGnB,QAAZD,EACFT,EAAO,OACEO,EAAQT,SAASW,IAAYT,IAASS,IAC/CT,EAAOS,EAEV,CAGD,OAAOH,EAAUN,IAASO,EAAQI,MAAMC,GAAMA,IAAMZ,KAAS,KAC/D,CAYO,SAASE,gBAAgBW,GAC9B,OAAOC,WAAWD,GAAQA,EAAOE,KAAKpC,UAAWkC,EACnD,CAYO,SAASG,UAAUC,EAAOjB,GAE/B,MAAa,QAATA,GAA0B,OAARA,EACbkB,OAAOC,KAAKF,EAAO,QAAQG,SAAS,UAItCH,CACT,CAOO,SAASI,aAEd,OAAO,IAAIC,MAAOF,WAAWjB,MAAM,KAAK,GAAGoB,MAC7C,CAOO,SAASC,iBACd,OAAO,IAAIF,MAAOG,SACpB,CAWO,SAASC,SAASC,GACvB,MAAgD,oBAAzCtC,OAAOC,UAAU8B,SAAS5B,KAAKmC,EACxC,CAWO,SAASC,cAAcD,GAC5B,MACkB,iBAATA,IACNzC,MAAMC,QAAQwC,IACN,OAATA,GAC6B,IAA7BtC,OAAOwC,KAAKF,GAAMG,MAEtB,CAWO,SAASC,uBAAuBJ,GASrC,MARsB,CACpB,mDACA,uEACA,wEACA,uFACA,qEAGmBK,MAAMC,GAAYA,EAAQC,KAAKP,IACtD,CASO,SAASQ,cACd,MAAMC,EAAQC,QAAQC,OAAOC,SAC7B,MAAO,IAAMC,OAAOH,QAAQC,OAAOC,SAAWH,GAAS,GACzD,CAYO,SAASK,YAAYC,EAAOC,EAAY,GAC7C,MAAMC,EAAaC,KAAKC,IAAI,GAAIH,GAAa,GAC7C,OAAOE,KAAKE,OAAOL,EAAQE,GAAcA,CAC3C,CA6BO,SAASI,WAAWC,EAAYC,EAAoBC,GAAa,GACtE,GAAIF,GAAoC,iBAAfA,EAGvB,OAFAA,EAAaA,EAAW1B,QAET6B,SAAS,OAEfF,EACHF,WACEK,aAAanD,gBAAgB+C,GAAa,QAC1CC,EACAC,GAEF,MAEHA,IACAF,EAAWK,WAAW,eACrBL,EAAWK,WAAW,gBACtBL,EAAWK,WAAW,SACtBL,EAAWK,WAAW,UAGjB,IAAIL,OAINA,EAAWpD,QAAQ,KAAM,GAEpC,CCvXA,MAAM0D,OAAS,CAAC,MAAO,SAAU,OAAQ,OAAQ,SAG3CC,QAAU,CAEdC,WAAW,EACXC,QAAQ,EACRC,aAAa,EAEbC,UAAW,GAEXC,WAAY,CACV,CACEC,MAAO,QACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,UACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,SACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,UACPC,MAAOR,OAAO,IAEhB,CACEO,MAAO,YACPC,MAAOR,OAAO,MAkBb,SAASS,OAAOC,GACrB,MAAOC,KAAaC,GAASF,GAGvBJ,WAAEA,EAAUO,MAAEA,GAAUZ,QAG9B,GACe,IAAbU,IACc,IAAbA,GAAkBA,EAAWE,GAASA,EAAQP,EAAW/B,QAE1D,OAIF,MAAMuC,EAAS,GAAGhD,iBAAiBwC,EAAWK,EAAW,GAAGJ,WAGxDN,QAAQE,QACVY,WAAWH,EAAOE,GAIhBb,QAAQC,WACVc,QAAQP,IAAIQ,WACVC,EACA,CAACJ,EAAOjD,WAAWoC,QAAQK,WAAWK,EAAW,GAAGH,QAAQW,OAAOP,GAGzE,CAgBO,SAASQ,aAAaT,EAAUU,EAAOC,GAE5C,MAAMC,EAAcD,GAAkBD,GAASA,EAAMG,SAAY,IAG3DX,MAAEA,EAAKP,WAAEA,GAAeL,QAG9B,GAAiB,IAAbU,GAAkBA,EAAWE,GAASA,EAAQP,EAAW/B,OAC3D,OAIF,MAAMuC,EAAS,GAAGhD,iBAAiBwC,EAAWK,EAAW,GAAGJ,WAGtDkB,EAAeJ,GAASA,EAAMK,MAG9Bd,EAAQ,CAACW,GACXE,GACFb,EAAMe,KAAK,KAAMF,GAIfxB,QAAQE,QACVY,WAAWH,EAAOE,GAIhBb,QAAQC,WACVc,QAAQP,IAAIQ,WACVC,EACA,CAACJ,EAAOjD,WAAWoC,QAAQK,WAAWK,EAAW,GAAGH,QAAQW,OAAO,CACjEP,EAAM/D,QAAQmD,OAAOW,EAAW,OAC7BC,IAIX,CAaO,SAASgB,aAAajB,EAAUkB,EAAQP,GAC7CF,aACET,EACA,KACA,CACE,GAAGW,GAAiB,0EAChBO,GAAU,IAAIC,KAAKC,GAAU,KAAKA,EAAMP,aAC5ChE,KAAK,MAEX,CAUO,SAASwE,YAAYC,GAE1B,MAAMpB,MAAEA,EAAKqB,KAAEA,EAAIC,KAAEA,EAAIjC,UAAEA,EAASC,OAAEA,GAAW8B,EAGjDhC,QAAQG,aAAc,EACtBH,QAAQI,UAAY,GAGpB+B,YAAYvB,GAGZwB,qBAAqBnC,GAGrBoC,kBAAkBJ,EAAMC,EAAMhC,EAChC,CAUO,SAASiC,YAAYvB,GAExB5B,OAAOsD,UAAU1B,IACjBA,GAAS,GACTA,GAASZ,QAAQK,WAAW/B,SAG5B0B,QAAQY,MAAQA,EAEpB,CASO,SAASwB,qBAAqBnC,GAEnCD,QAAQC,YAAcA,CACxB,CAaO,SAASoC,kBAAkBJ,EAAMC,EAAMhC,GAE5CF,QAAQE,SAAWA,EAGfF,QAAQE,SACVF,QAAQiC,KAAOA,GAAQ,GACvBjC,QAAQkC,KAAOA,GAAQ,GAE3B,CAYA,SAASpB,WAAWH,EAAOE,GACpBb,QAAQG,eAEVoC,WAAW7F,gBAAgBsD,QAAQiC,QAClCO,UAAU9F,gBAAgBsD,QAAQiC,OAGpCjC,QAAQI,UAAY1D,gBAAgBa,KAAKyC,QAAQiC,KAAMjC,QAAQkC,OAI/DlC,QAAQG,aAAc,GAIxBsC,WACEzC,QAAQI,UACR,CAACS,GAAQK,OAAOP,GAAOpD,KAAK,KAAO,MAClC6D,IACKA,GAASpB,QAAQE,QAAUF,QAAQG,cACrCH,QAAQE,QAAS,EACjBF,QAAQG,aAAc,EACtBgB,aAAa,EAAGC,EAAO,yCACxB,GAGP,CCvQO,MAAMsB,cAAgB,CAC3BC,UAAW,CACTlC,KAAM,CACJvB,MAAO,CACL,mCACA,kBACA,0CACA,2BACA,kCACA,kCACA,wCACA,2CACA,qBACA,4BACA,2CACA,uDACA,6BACA,yBACA,0BACA,+BACA,uBACA,uFACA,yBACA,oCACA,oBACA,0BACA,8CACA,2BACA,0BACA,6BACA,mCACA,wCACA,mCACA,2BACA,kCACA,uBACA,iBACA,yBACA,8BACA,oBACA,2BACA,eACA,6BACA,iBACA,aACA,eACA,sBACA,cACA,yBACA,oBACA,uBAEF0D,MAAO,CAAC,YACRC,QAAS,iBACTC,QAAS,gBACTC,YAAa,+BACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBC,WAAY,CACVC,QAAS,CACPjE,MAAO,SACP0D,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbxG,KAAM,SAGV4G,OAAQ,CACNlE,MAAO,8BACP0D,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbxG,KAAM,SAGV6G,WAAY,CACVnE,OAAO,EACP0D,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbxG,KAAM,WAGV8G,UAAW,CACTpE,MAAO,SACP0D,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbxG,KAAM,SAGV+G,YAAa,CACXrE,MAAO,CAAC,aAAc,kBAAmB,iBACzC0D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBC,cAAe,CACbvE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbxG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbxG,KAAM,SAGVA,KAAM,CACJ0C,MAAO,MACP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"} \ No newline at end of file +{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, join } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? path : join(__dirname, path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || '';\r\n logging.file = file || '';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initGlobalOptions(defaultConfig);\r\n\r\n// An object for the instance options, created each time the `initExport` occurs\r\nconst instanceOptions = deepCopy(globalOptions);\r\n\r\n/**\r\n * Retrieves a reference to the options object. Depending on the `getInstance`\r\n * parameter, it returns either the global options or the instance-specific\r\n * options object.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getInstance=true] - Optional parameter that decides whether\r\n * to return the instance-specific options (when `true`) or the global options\r\n * (when `false`). The default value is `true`.\r\n *\r\n * @returns {Object} A reference to either the global options\r\n * or the instance-specific options, based on the `getInstance` parameter.\r\n */\r\nexport function getOptions(getInstance = true) {\r\n return getInstance ? instanceOptions : globalOptions;\r\n}\r\n\r\n/**\r\n * Sets the global options of the export server, keeping the principle\r\n * of the options load priority from all available sources. It accepts optional\r\n * `customOptions` object and `cliArgs` array with arguments from the CLI. These\r\n * options will be validated and applied if provided.\r\n *\r\n * The priority order of setting values is:\r\n *\r\n * 1. Options from the `lib/schemas/config.js` file (default values).\r\n * 2. Options from a custom JSON file (loaded by the `loadConfig` option).\r\n * 3. Options from the environment variables (the `.env` file).\r\n * 4. Options from the command line interface (CLI).\r\n * 5. Options from the first parameter (the `customOptions` is by default\r\n * an empty object).\r\n *\r\n * @function setGlobalOptions\r\n *\r\n * @param {Object} [customOptions={}] - Optional custom options for additional\r\n * configuration. The default value is an empty object.\r\n * @param {Array.} [cliArgs=[]] - Optional command line arguments\r\n * for additional configuration. The default value is an empty array.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from all available sources.\r\n */\r\nexport function setGlobalOptions(customOptions = {}, cliArgs = []) {\r\n // Object for options loaded via the `loadConfig` option\r\n let configOptions = {};\r\n\r\n // Object for options from the CLI\r\n let cliOptions = {};\r\n\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Validate options from the custom JSON loaded via the `loadConfig`\r\n configOptions = strictValidate(\r\n _loadConfigFile(cliArgs, globalOptions.customLogic)\r\n );\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options from the `loadConfig` option validation error'\r\n );\r\n }\r\n\r\n try {\r\n // Validate options from the CLI\r\n cliOptions = looseValidate(_pairArgumentValue(nestedProps, cliArgs));\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] CLI options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Apply custom options if there are any\r\n if (\r\n customOptions &&\r\n isObject(customOptions) &&\r\n Object.keys(customOptions).length\r\n ) {\r\n try {\r\n // Validate custom options provided by the user\r\n customOptions = strictValidate(customOptions);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Update values of the global options with values from each source possible\r\n _updateGlobalOptions(\r\n defaultConfig,\r\n globalOptions,\r\n configOptions,\r\n cliOptions,\r\n customOptions\r\n );\r\n\r\n // Return updated global options\r\n return globalOptions;\r\n}\r\n\r\n/**\r\n * Updates the instance options with additional options. It optionally allows\r\n * to reinitialize the instance options with the values of a current global\r\n * options object.\r\n *\r\n * @param {Object} updateOptions - The update options to merge into the instance\r\n * options.\r\n * @param {boolean} [newInstance=false] - A flag to indicate whether to init\r\n * options for a new instance. If `true`, the existing instance options will\r\n * be cleared and reinitialized based on the global options.\r\n *\r\n * @returns {Object} - The updated instance options.\r\n */\r\nexport function updateOptions(updateOptions, newInstance = false) {\r\n // Check if options need to be created for a new instance\r\n if (newInstance) {\r\n // Get rid of the old instance options\r\n Object.keys(instanceOptions).forEach((key) => {\r\n delete instanceOptions[key];\r\n });\r\n\r\n // Init the new instance options based on the global options\r\n mergeOptions(instanceOptions, deepCopy(globalOptions));\r\n }\r\n\r\n // Merge additional options to the instance options\r\n mergeOptions(instanceOptions, updateOptions);\r\n\r\n // Return the reference to the instance options object\r\n return instanceOptions;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty array.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n .bold.yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns global options object based on provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * @function _initGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object to be used for initializing\r\n * options.\r\n *\r\n * @returns {Object} Initialized options object.\r\n */\r\nfunction _initGlobalOptions(config) {\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[item.envLink];\r\n if (envVal !== undefined && envVal !== null) {\r\n options[name] = envVal;\r\n } else {\r\n options[name] = item.value;\r\n }\r\n } else {\r\n options[name] = _initGlobalOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Updates global options object with values from various sources, following\r\n * a specific prioritization order. The function checks for values in the order\r\n * of precedence: the `loadConfig` configuration options, environment variables,\r\n * custom options, and CLI options.\r\n *\r\n * @function _updateGlobalOptions\r\n *\r\n * @param {Object} config - The configuration object, which includes the initial\r\n * settings and metadata for each option. This object is used to determine\r\n * the structure and default values for the options.\r\n * @param {Object} options - The global options object that will be updated\r\n * with values from other sources.\r\n * @param {Object} configOpt - The configuration options object, loaded with\r\n * the `loadConfig` option, which may provide values to override defaults.\r\n * @param {Object} cliOpt - The CLI options object, which may include values\r\n * provided through command-line arguments and may override configuration\r\n * options.\r\n * @param {Object} customOpt - The custom options object, typically containing\r\n * additional and user-defined values, which has the highest precedence among\r\n * options.\r\n */\r\nfunction _updateGlobalOptions(config, options, configOpt, cliOpt, customOpt) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the config entry of a specific option\r\n const entry = config[key];\r\n\r\n // Gather values for the options from every possible source, if exists\r\n const configVal = configOpt && configOpt[key];\r\n const cliVal = cliOpt && cliOpt[key];\r\n const customVal = customOpt && customOpt[key];\r\n\r\n // If the value not found, need to go deeper\r\n if (typeof entry.value === 'undefined') {\r\n _updateGlobalOptions(entry, options[key], configVal, cliVal, customVal);\r\n } else {\r\n // If a value from custom JSON options exists, it takes precedence\r\n if (configVal !== undefined && configVal !== null) {\r\n options[key] = configVal;\r\n }\r\n\r\n // If a value from environment variables exists, it takes precedence\r\n const envVal = envs[entry.envLink];\r\n if (entry.envLink in envs && envVal !== undefined && envVal !== null) {\r\n options[key] = envVal;\r\n }\r\n\r\n // If a value from CLI options exists, it takes precedence\r\n if (cliVal !== undefined && cliVal !== null) {\r\n options[key] = cliVal;\r\n }\r\n\r\n // If a value from user options exists, it takes precedence\r\n if (customVal !== undefined && customVal !== null) {\r\n options[key] = customVal;\r\n }\r\n }\r\n });\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `loadConfig` option and the corresponding file path.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs, customLogicOptions) {\r\n // Check if the `loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `loadConfig` is present and has a correct value\r\n if (configFileName && customLogicOptions.allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n setGlobalOptions,\r\n updateOptions,\r\n mergeOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Get the reference to the global options to update to the new version\r\n const options = getOptions();\r\n\r\n // Set to the new version\r\n options.highcharts.version = newVersion;\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = !file.startsWith('http') ? true : false;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: join(__dirname, cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const result = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n getOptions,\r\n isAllowedConfig,\r\n mergeOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n deepCopy,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n isObject,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Validate single export options\r\n options = validateOptions(options);\r\n\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // Validate batch export options\r\n options = validateOptions(options);\r\n\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `exportingOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} exportingOptions - The `exportingOptions` object, which\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(exportingOptions, endCallback) {\r\n try {\r\n // Check if provided options is an object\r\n if (!isObject(exportingOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `exportingOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = mergeOptions(deepCopy(getOptions()), {\r\n export: exportingOptions.export,\r\n customLogic: exportingOptions.customLogic\r\n });\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Validate option\r\n handledResources = validateOption('resources', handledResources);\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled\r\n if (rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Validate the request options and store parsed structure in the request\r\n request.validatedOptions = validateOptions({\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n });\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n let newVersion = request.params.newVersion;\r\n\r\n // Validate the version\r\n try {\r\n newVersion = validateOption('version', request.params.newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version is incorrect: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // When a correct value found\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: serverOptions\r\n })\r\n );\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = await readFile(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n })\r\n );\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n updateOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n // Init, validate and update the instance options object\r\n const options = updateOptions(validateOptions(initOptions), true);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n setGlobalOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n level\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","join","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initGlobalOptions","instanceOptions","getOptions","getInstance","setGlobalOptions","customOptions","cliArgs","cliOptions","_loadConfigFile","_pairArgumentValue","_updateGlobalOptions","updateOptions","newInstance","mergeOptions","originalOptions","newOptions","entries","mapToNewOptions","oldOptions","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","envVal","configOpt","cliOpt","customOpt","configVal","cliVal","customVal","stringifyFunctions","stringify","replaceAll","customLogicOptions","configIndex","findIndex","arg","configFileName","i","option","async","fetch","requestOptions","Promise","resolve","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","exportingOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","readFile","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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ACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBE,iBAAkB,CAChBxE,MAAO,CAAC,kBACR0D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbxG,KAAM,cACNgH,aAAc,0DAGlBG,cAAe,CACbzE,MAAO,CACL,wEACA,kGAEF0D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbxG,KAAM,OACNyG,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN3E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbxG,KAAM,SAGVsH,MAAO,CACL5E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbxG,KAAM,SAGVuH,QAAS,CACP7E,MAAO,KACP0D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbxG,KAAM,SAGVwH,IAAK,CACH9E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbxG,KAAM,SAGVyH,MAAO,CACL/E,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbxG,KAAM,SAGVC,QAAS,CACPyC,MAAO,KACP0D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbxG,KAAM,SAGVA,KAAM,CACJ0C,MAAO,MACP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"} \ No newline at end of file diff --git a/lib/config.js b/lib/config.js index 4014901a..6aed4344 100644 --- a/lib/config.js +++ b/lib/config.js @@ -24,7 +24,7 @@ import { readFileSync } from 'fs'; import { join } from 'path'; import { log, logWithStack, logZodIssues } from './logger.js'; -import { __dirname, isObject, deepCopy, getAbsolutePath } from './utils.js'; +import { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js'; import { envs, looseValidate, @@ -32,7 +32,7 @@ import { validators } from './validation.js'; -import { defaultConfig, nestedProps, absoluteProps } from './schemas/config.js'; +import { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js'; import ExportError from './errors/ExportError.js'; diff --git a/lib/index.js b/lib/index.js index 3edeb8f4..e716c7c3 100644 --- a/lib/index.js +++ b/lib/index.js @@ -30,9 +30,9 @@ import { } from './chart.js'; import { getOptions, - updateOptions, setGlobalOptions, mapToNewOptions, + updateOptions, validateOption, validateOptions } from './config.js'; diff --git a/lib/pool.js b/lib/pool.js index a67766b2..bea9f25f 100644 --- a/lib/pool.js +++ b/lib/pool.js @@ -23,7 +23,7 @@ See LICENSE file in root for details. import { Pool } from 'tarn'; import { v4 as uuid } from 'uuid'; -import { createBrowser, closeBrowser, newPage, clearPage } from './browser.js'; +import { clearPage, createBrowser, closeBrowser, newPage } from './browser.js'; import { puppeteerExport } from './export.js'; import { log, logWithStack } from './logger.js'; import { getNewDateTime, measureTime } from './utils.js'; diff --git a/lib/server/middlewares/validation.js b/lib/server/middlewares/validation.js index 4af2496e..551d1337 100644 --- a/lib/server/middlewares/validation.js +++ b/lib/server/middlewares/validation.js @@ -27,14 +27,8 @@ import { v4 as uuid } from 'uuid'; import { getAllowCodeExecution } from '../../chart.js'; import { isAllowedConfig, validateOptions } from '../../config.js'; -import { log, logZodIssues } from '../../logger.js'; -import { - fixConstr, - fixType, - isObjectEmpty, - isPrivateRangeUrlFound -} from '../../utils.js'; -import { looseValidate } from '../../validation.js'; +import { log } from '../../logger.js'; +import { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js'; import ExportError from '../../errors/ExportError.js'; diff --git a/lib/server/routes/health.js b/lib/server/routes/health.js index 1e50ab42..4a6d4d9b 100644 --- a/lib/server/routes/health.js +++ b/lib/server/routes/health.js @@ -22,7 +22,7 @@ import { join } from 'path'; import { getHighchartsVersion } from '../../cache.js'; import { log } from '../../logger.js'; -import { getPoolStats, getPoolInfoJSON } from '../../pool.js'; +import { getPoolInfoJSON, getPoolStats } from '../../pool.js'; import { addTimer } from '../../timer.js'; import { __dirname, getNewDateTime } from '../../utils.js'; diff --git a/lib/server/routes/versionChange.js b/lib/server/routes/versionChange.js index f8512576..d5db30f9 100644 --- a/lib/server/routes/versionChange.js +++ b/lib/server/routes/versionChange.js @@ -17,7 +17,7 @@ See LICENSE file in root for details. * on the server, with authentication and validation. */ -import { updateHighchartsVersion, getHighchartsVersion } from '../../cache.js'; +import { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js'; import { validateOption } from '../../config.js'; import { log } from '../../logger.js'; import { envs } from '../../validation.js'; From ee8a7eaed7db6516bcc8e6af607c881cf8b81d91 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Thu, 23 Jan 2025 03:29:29 +0100 Subject: [PATCH 16/19] Improved options validation by moving it into the updateOptions function. --- README.md | 7 ++++- dist/index.cjs | 4 +-- dist/index.esm.js | 2 +- dist/index.esm.js.map | 2 +- lib/chart.js | 13 +------- lib/config.js | 44 +++++++++++++--------------- lib/index.js | 42 ++++++++++++-------------- lib/server/middlewares/validation.js | 8 ++--- lib/server/routes/versionChange.js | 13 +------- lib/server/server.js | 22 ++++++-------- 10 files changed, 64 insertions(+), 93 deletions(-) diff --git a/README.md b/README.md index 8225db05..c7ee2421 100644 --- a/README.md +++ b/README.md @@ -115,6 +115,10 @@ The `singleExport()`, `batchExport()`, and `startExport()` functions must be pro Essentially, all options can be configured through `.env`, the CLI, and prompts, with one exception: the `HIGHCHARTS_ADMIN_TOKEN`, which is only available as an environment variable. +## Options Validation + +By default, options validation is enabled, and it is recommended to keep it enabled to ensure that the provided options are correctly checked, validated, and parsed, allowing the exporting process to function without issues. However, it is possible to disable validation (by setting the `validation` option to **false**) if you are confident in the accuracy of the data you provide. Additionaly, when used as a Node.js module, each API function that updates global options with the provided data also offers the ability to validate the data. + ## Default JSON Config The JSON below represents the default configuration stored in the `./lib/schemas/config.js` file. If no `.env` file is found (more details on the file and environment variables below), these options will be used. The configuration is not recommended to be modified directly, as it can typically be managed through other sources. @@ -766,10 +770,11 @@ This package supports both CommonJS and ES modules. - `@returns {Object}` A copy of the global options object, or a reference to the global options object. -- `function updateOptions(newOptions, getCopy = false)`: Updates a copy of the global options object or a reference to the global options object, based on the `getCopy` flag. +- `function updateOptions(newOptions, getCopy = false, strictCheck = true)`: Updates either a copy of the global options object or a reference to the global options object, depending on the getCopy flag, using the provided newOptions, which may or may not be validated. - `@param {Object} newOptions` - An object containing the new options to be merged into the global options. - `@param {boolean} [getCopy=false]` - Determines whether to merge the new options into a copy of the global options object (`true`) or directly into the global options object (`false`). The default value is `false`. + - `@param {boolean} [strictCheck=true]` - Determines if stricter validation should be applied. The default value is `true`. - `@returns {Object}` The updated options object, either the modified global options or a modified copy, based on the value of `getCopy`. diff --git a/dist/index.cjs b/dist/index.cjs index 3bff04ac..1624bfe6 100644 --- a/dist/index.cjs +++ b/dist/index.cjs @@ -1,2 +1,2 @@ -"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?path.normalize(e):path.resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),i=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):zod.z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>zod.z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1){return _mergeOptions(getOptions(t),e)}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),i=path.join(r,"manifest.json"),n=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(fs.readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=updateOptions({highcharts:{version:e}});await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await fetch(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,i){let n;const s=r.host,a=r.port;if(s&&a)try{n=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=n?{agent:n,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,i,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,i))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,i=e.cdnUrl||cache.cdnUrl;try{const n={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${i}/${r}/${e}`:`${i}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`))],e.customScripts,t,n),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),n}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=i(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){let i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:getAbsolutePath(e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=i?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const i=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${i()}ms.`).setError(n);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${i()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);e=validateOptions(e),await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):fs.writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{e=validateOptions(e);const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):fs.writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let i=e,n=!1;if(t&&e.endsWith(".json"))try{i=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else i=isAllowedConfig(e,!1,o),i&&!t&&delete i.files;for(const e in i)r.includes(e)?n||(n=!0):delete i[e];return n?(i.files&&(i.files=i.files.map((e=>e.trim())),(!i.files||i.files.length<=0)&&delete i.files),i=validateOption("resources",i),i):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions=validateOptions({requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}}),o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let i=e.params.newVersion;try{i=validateOption("version",e.params.newVersion)}catch(e){throw new ExportError(`[version] Version is incorrect: ${e.message}`,400).setError(e)}if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions(validateOptions({server:e}));if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions(validateOptions({server:{rateLimiting:e}}));rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=updateOptions(validateOptions(e));setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions(validateOptions({logging:{level:e}})).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions(validateOptions({logging:{toConsole:e}})).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions(validateOptions({logging:{dest:e,file:t,toFile:o}}));enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};exports.default=index,exports.initExport=initExport; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || '';\r\n    logging.file = file || '';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or a reference to the global\r\n * options object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `false`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n  return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates a copy of the global options object or a reference to the global\r\n * options object, based on the `getCopy` flag.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false) {\r\n  // Merge new options to the global options or its copy and return the result\r\n  return _mergeOptions(getOptions(getCopy), newOptions);\r\n}\r\n\r\n/**\r\n * Updates the global options with values provided through the CLI, keeping\r\n * the principle of options load priority. This function accepts a `cliArgs`\r\n * array containing arguments from the CLI, which will be validated and applied\r\n * if provided.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n * 2. Values from the command line interface (CLI).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array.<string>} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Validate options from the custom JSON loaded via the `--loadConfig`\r\n      const configOptions = strictValidate(_loadConfigFile(cliArgs));\r\n\r\n      // Update global options with the values from the `configOptions`\r\n      updateOptions(configOptions);\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] Custom options from the `loadConfig` option validation error'\r\n      );\r\n    }\r\n\r\n    try {\r\n      // Validate options from the CLI\r\n      const cliOptions = looseValidate(\r\n        _pairArgumentValue(nestedProps, cliArgs)\r\n      );\r\n\r\n      // Update global options with the values from the `cliOptions`\r\n      updateOptions(cliOptions);\r\n    } catch (error) {\r\n      logZodIssues(\r\n        1,\r\n        error.issues,\r\n        '[validation] CLI options validation error'\r\n      );\r\n    }\r\n  }\r\n\r\n  // Return reference to the global options\r\n  return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty array.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n        .bold.yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from the `./lib/schemas/config.js` file (defaults).\r\n * 2. Values from environment variables (specified in the `.env` file).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n  // Init the object for options\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // Set the correct value based on the established priority order\r\n      if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n        // The environment variables value\r\n        options[name] = envs[item.envLink];\r\n      } else {\r\n        // The value from the config file\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      // Create a section in the options\r\n      options[name] = _initOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function _mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? _mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n  // Get the allow flags for the custom logic check\r\n  const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n  // Check if the `--loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `--loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `--loadConfig` is present and has a correct value\r\n  if (configFileName && allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  updateOptions,\r\n  setCliOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules.\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = extractVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Update to the new version\r\n  const options = updateOptions({\r\n    highcharts: {\r\n      version: newVersion\r\n    }\r\n  });\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = file.startsWith('http') ? false : true;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: getAbsolutePath(cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const result = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n  isAllowedConfig,\r\n  updateOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  isObject,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Validate single export options\r\n    options = validateOptions(options);\r\n\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // Validate batch export options\r\n    options = validateOptions(options);\r\n\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n  try {\r\n    // Check if provided options are in an object\r\n    if (!isObject(imageOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = updateOptions(\r\n      {\r\n        export: imageOptions.export,\r\n        customLogic: imageOptions.customLogic\r\n      },\r\n      true\r\n    );\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Validate option\r\n  handledResources = validateOption('resources', handledResources);\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled and the app exists\r\n    if (app && rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Validate the request options and store parsed structure in the request\r\n    request.validatedOptions = validateOptions({\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    });\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      log(4, '[ui] Returning UI for the export.');\r\n\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      let newVersion = request.params.newVersion;\r\n\r\n      // Validate the version\r\n      try {\r\n        newVersion = validateOption('version', request.params.newVersion);\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          `[version] Version is incorrect: ${error.message}`,\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // When a correct value found\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        server: serverOptions\r\n      })\r\n    );\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions(\r\n    validateOptions({\r\n      server: {\r\n        rateLimiting: rateLimitingOptions\r\n      }\r\n    })\r\n  );\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} initOptions - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration.\r\n */\r\nexport async function initExport(initOptions) {\r\n  // Init, validate and update the options object\r\n  const options = updateOptions(validateOptions(initOptions));\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          level\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          toConsole\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions(\r\n      validateOptions({\r\n        logging: {\r\n          dest,\r\n          file,\r\n          toFile\r\n        }\r\n      })\r\n    );\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","normalize","resolve","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initOptions","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","async","fetch","url","requestOptions","Promise","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","i","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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C,aAAc,kBAAmB,iBACzC2D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBC,cAAe,CACbxE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBE,iBAAkB,CAChBzE,MAAO,CAAC,kBACR2D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBG,cAAe,CACb1E,MAAO,CACL,wEACA,kGAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACb1G,KAAM,OACN2G,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN5E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACb1G,KAAM,SAGVwH,MAAO,CACL7E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACb1G,KAAM,SAGVyH,QAAS,CACP9E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACb1G,KAAM,SAGV0H,IAAK,CACH/E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACb1G,KAAM,SAGV2H,MAAO,CACLhF,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,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"} +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return path.isAbsolute(e)?path.normalize(e):path.resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:n}=logging;if(5!==t&&(0===t||t>n||n>r.length))return;const i=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:n,levelsDesc:i}=logging;if(0===e||e>n||n>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:n,toFile:i}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(n),enableFileLogging(o,r,i)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const n=e[r];void 0===n.value?_createNestedProps(n,t,`${o}.${r}`):(t[n.cliName||r]=`${o}.${r}`.substring(1),void 0!==n.legacyName&&(t[n.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),n=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(i):zod.z.union([n,r]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>zod.z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1,o=!0){return _mergeOptions(getOptions(t),validateOptions(e,o))}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,n)=>t[o]=e.length-1===n?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),n=path.join(r,"manifest.json"),i=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(n)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let r=!1;const s=JSON.parse(fs.readFileSync(n),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=updateOptions({highcharts:{version:e}});await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const n=await fetch(`${e}.js`,t);if(200===n.statusCode&&"string"==typeof n.text){if(o){o[extractModuleName(e)]=1}return n.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${n.statusCode}).`,404).setError(n);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,n){let i;const s=r.host,a=r.port;if(s&&a)try{i=new httpsProxyAgent.HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=i?{agent:i,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,n,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,n))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,n=e.cdnUrl||cache.cdnUrl;try{const i={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${n}/${r}/${e}`:`${n}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${n}/maps/${r}/modules/${e}`:`${n}/maps/modules/${e}`:r?`${n}/${r}/modules/${e}`:`${n}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${n}/stock/${r}/indicators/${e}`:`${n}/stock/indicators/${e}`))],e.customScripts,t,i),cache.hcVersion=extractVersion(cache.sources),fs.writeFileSync(o,cache.sources),i}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:n,wrap:i}=Highcharts;Highcharts.setOptionsObj=n(!1,{},o()),window.isRenderComplete=!1,i(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=n(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),i(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=n(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...n}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&n};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const n=[];if(r.js&&n.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");n.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of n)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}n.length=0;const i=[];if(r.css){let n=r.css.match(/@import\s*([^;]*);/g);if(n)for(let e of n)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:getAbsolutePath(e)}));i.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let n=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;n=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const i=n?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||t.height)),c=Math.abs(Math.ceil(i.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:n?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:n}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(n>1?n:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const n=measureTime(),i=await puppeteerExport(t.page,e.export,e.customLogic);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(i):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${n()}ms.`).setError(i);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${n()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:n,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${n}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r||`chart.${n}`,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:n}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||n?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||n?.sourceHeight||r?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||n?.sourceWidth||r?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(fs.readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let n=e,i=!1;if(t&&e.endsWith(".json"))try{n=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else n=isAllowedConfig(e,!1,o),n&&!t&&delete n.files;for(const e in n)r.includes(e)?i||(i=!0):delete n[e];return i?(n.files&&(n.files=n.files.map((e=>e.trim())),(!n.files||n.files.length<=0)&&delete n.files),n=validateOption("resources",n),n):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:n,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:n,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const n=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(n),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const n=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,n);if(null===i&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions={requestId:r,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,n),themeOptions:isAllowedConfig(t.themeOptions,!0,n)},customLogic:{allowCodeExecution:n,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,n)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const n=e.validatedOptions,i=n.requestId;log(4,`[export] Request [${i}] - Got an incoming HTTP request.`),await startExport(n,((n,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(n)throw n;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${i}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:n,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),n||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const n=e.params.newVersion;if(!n)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(n)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${n}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),n=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(n.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=updateOptions(e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};exports.default=index,exports.initExport=initExport; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? wrapAround(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean,\r\n  wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || '';\r\n    logging.file = file || '';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains.  The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion.  The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  defaultConfig,\r\n  nestedProps,\r\n  absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets or updates the HTTP status code for the error.\r\n   *\r\n   * @param {number} statusCode - The HTTP status code to assign to the error.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setStatus(statusCode) {\r\n    this.statusCode = statusCode;\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    this.error = error;\r\n\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or a reference to the global\r\n * options object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `false`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n  return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates either a copy of the global options object or a reference\r\n * to the global options object, depending on the getCopy flag, using\r\n * the provided newOptions, which may or may not be validated.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false, strictCheck = true) {\r\n  // Merge new options to the global options or its copy and return the result\r\n  return _mergeOptions(\r\n    // First, get the options\r\n    getOptions(getCopy),\r\n    // Next, validate the new options\r\n    validateOptions(newOptions, strictCheck)\r\n  );\r\n}\r\n\r\n/**\r\n * Updates the global options with values provided through the CLI, keeping\r\n * the principle of options load priority. This function accepts a `cliArgs`\r\n * array containing arguments from the CLI, which will be validated and applied\r\n * if provided.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n * 2. Values from the command line interface (CLI).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array.<string>} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Get options from the custom JSON loaded via the `--loadConfig`\r\n      const configOptions = _loadConfigFile(cliArgs);\r\n\r\n      // Update global options with validated values from the `configOptions`\r\n      updateOptions(configOptions);\r\n    } catch (error) {\r\n      log(2, '[validation] No options added from the `--loadConfig` option.');\r\n    }\r\n\r\n    try {\r\n      // Get options from the CLI\r\n      const cliOptions = _pairArgumentValue(nestedProps, cliArgs);\r\n\r\n      // Update global options with validated values from the `cliOptions`\r\n      updateOptions(cliOptions, false, false);\r\n    } catch (error) {\r\n      log(2, '[validation] No options added from the CLI arguments.');\r\n    }\r\n  }\r\n\r\n  // Return reference to the global options\r\n  return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty array.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return null if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return null if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n  // Print the logo and version information\r\n  printVersion();\r\n\r\n  // Print the license information\r\n  console.log(\r\n    'This software requires a valid Highcharts license for commercial use.\\n'\r\n      .yellow,\r\n    '\\nFor a full list of CLI options, type:',\r\n    '\\nhighcharts-export-server --help\\n'.green,\r\n    '\\nIf you do not have a license, one can be obtained here:',\r\n    '\\nhttps://shop.highsoft.com/\\n'.green,\r\n    '\\nTo customize your installation, please refer to the README file at:',\r\n    '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n  );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n  // Display README and general usage information\r\n  console.log(\r\n    '\\nUsage of CLI arguments:'.bold,\r\n    '\\n-----------------------',\r\n    `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n  );\r\n\r\n  // Iterate through each category in the `defaultConfig` and display usage info\r\n  Object.keys(defaultConfig).forEach((category) => {\r\n    console.log(`${category.toUpperCase()}`.bold.red);\r\n    _cycleCategories(defaultConfig[category]);\r\n    console.log('');\r\n  });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n  // Get package version either from `.env` or from `package.json`\r\n  const packageVersion = JSON.parse(\r\n    readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n  ).version;\r\n\r\n  // Print text only\r\n  if (noLogo) {\r\n    console.log(`Highcharts Export Server v${packageVersion}`);\r\n  } else {\r\n    // Print the logo\r\n    console.log(\r\n      readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n        .bold.yellow,\r\n      `v${packageVersion}\\n`.bold\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from the `./lib/schemas/config.js` file (defaults).\r\n * 2. Values from environment variables (specified in the `.env` file).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n  // Init the object for options\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // Set the correct value based on the established priority order\r\n      if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n        // The environment variables value\r\n        options[name] = envs[item.envLink];\r\n      } else {\r\n        // The value from the config file\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      // Create a section in the options\r\n      options[name] = _initOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function _mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? _mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If value is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If allowFunctions is set to true, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.<string>} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n  // Get the allow flags for the custom logic check\r\n  const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n  // Check if the `--loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `--loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `--loadConfig` is present and has a correct value\r\n  if (configFileName && allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.<string>} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n  for (const [name, option] of Object.entries(options)) {\r\n    // If the current entry is a category and not a leaf option, recurse into it\r\n    if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n      _cycleCategories(option);\r\n    } else {\r\n      // Prepare description\r\n      const descName = ` --${option.cliName || name}`;\r\n\r\n      // Get the value\r\n      let optionValue = option.value;\r\n\r\n      // Prepare value for option that is not null and is array of strings\r\n      if (optionValue !== null && option.types.includes('string[]')) {\r\n        optionValue =\r\n          '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n      }\r\n\r\n      // Prepare value for option that is not null and is a string\r\n      if (optionValue !== null && option.types.includes('string')) {\r\n        optionValue = `'${optionValue}'`;\r\n      }\r\n\r\n      // Display correctly aligned messages\r\n      console.log(\r\n        descName.green,\r\n        `${('<' + option.types.join('|') + '>').yellow}`,\r\n        `${String(optionValue).bold}`.blue,\r\n        `- ${option.description}.`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  updateOptions,\r\n  setCliOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig,\r\n  printLicense,\r\n  printUsage,\r\n  printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with requestOptions\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  fetch,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n  highchartsOptions,\r\n  serverProxyOptions\r\n) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules.\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = extractVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n  // Update to the new version\r\n  const options = updateOptions({\r\n    highcharts: {\r\n      version: newVersion\r\n    }\r\n  });\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n  const newManifest = {\r\n    version: highchartsOptions.version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = newManifest;\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(newManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.<string>} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.<string>} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.<string>} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n  coreScripts,\r\n  moduleScripts,\r\n  customScripts,\r\n  serverProxyOptions,\r\n  fetchedModules\r\n) {\r\n  // Configure proxy if exists\r\n  let proxyAgent;\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a Proxy Agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // If exists, add proxy agent to request options\r\n  const requestOptions = proxyAgent\r\n    ? {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      }\r\n    : {};\r\n\r\n  const allFetchPromises = [\r\n    ...coreScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n    ),\r\n    ...moduleScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n    ),\r\n    ...customScripts.map((script) =>\r\n      _fetchAndProcessScript(`${script}`, requestOptions)\r\n    )\r\n  ];\r\n\r\n  const fetchedScripts = await Promise.all(allFetchPromises);\r\n  return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  // Get Highcharts version for scripts\r\n  const hcVersion =\r\n    highchartsOptions.version === 'latest'\r\n      ? null\r\n      : `${highchartsOptions.version}`;\r\n\r\n  // Get the CDN url for scripts\r\n  const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n  try {\r\n    const fetchedModules = {};\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    cache.sources = await _fetchScripts(\r\n      [\r\n        ...highchartsOptions.coreScripts.map((c) =>\r\n          hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n        )\r\n      ],\r\n      [\r\n        ...highchartsOptions.moduleScripts.map((m) =>\r\n          m === 'map'\r\n            ? hcVersion\r\n              ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/maps/modules/${m}`\r\n            : hcVersion\r\n              ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n              : `${cdnUrl}/modules/${m}`\r\n        ),\r\n        ...highchartsOptions.indicatorScripts.map((i) =>\r\n          hcVersion\r\n            ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n            : `${cdnUrl}/stock/indicators/${i}`\r\n        )\r\n      ],\r\n      highchartsOptions.customScripts,\r\n      serverProxyOptions,\r\n      fetchedModules\r\n    );\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = extractVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\nexport default {\r\n  checkAndUpdateCache,\r\n  getHighchartsVersion,\r\n  updateHighchartsVersion,\r\n  extractVersion,\r\n  extractModuleName,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n\r\n    const open = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await open();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      await open();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array.<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use resources\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = file.startsWith('http') ? false : true;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: getAbsolutePath(cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = isSVG\r\n      ? await page.evaluate((scale) => {\r\n          const svgElement = document.querySelector(\r\n            '#chart-container svg:first-of-type'\r\n          );\r\n\r\n          // Get the values correctly scaled\r\n          const chartHeight = svgElement.height.baseVal.value * scale;\r\n          const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n          // In case of SVG the zoom must be set directly for body as scale\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = scale;\r\n\r\n          // Set the margin to 0px\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.margin = '0px';\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        }, parseFloat(exportOptions.scale))\r\n      : await page.evaluate(() => {\r\n          // eslint-disable-next-line no-undef\r\n          const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n          // No need for such scale manipulation in case of other types\r\n          // of exports. Reset the zoom for other exports than to SVGs\r\n          // eslint-disable-next-line no-undef\r\n          document.body.style.zoom = 1;\r\n\r\n          return {\r\n            chartHeight,\r\n            chartWidth\r\n          };\r\n        });\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Save the start time\r\n    const workStart = getNewDateTime();\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const result = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (result instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // NOTE:\r\n      // Only page.screenshot will throw this, timeouts for PDF's are\r\n      // handled by the page.pdf function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (result.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        result.name === 'TimeoutError' ||\r\n        result.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(result);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(result);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Used for statistics in averageTime and processedWorkCount, which\r\n    // in turn is used by the /health route.\r\n    const workEnd = getNewDateTime();\r\n    const exportTime = workEnd - workStart;\r\n\r\n    poolStats.timeSpent += exportTime;\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n    // Otherwise return the result\r\n    return {\r\n      result,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a TargetCloseError, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfo,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { isAllowedConfig, updateOptions, validateOption } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n  fixConstr,\r\n  fixOutfile,\r\n  fixType,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  isObject,\r\n  roundNumber,\r\n  wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n  try {\r\n    // Check if provided options are in an object\r\n    if (!isObject(imageOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = updateOptions(\r\n      {\r\n        export: imageOptions.export,\r\n        customLogic: imageOptions.customLogic\r\n      },\r\n      true\r\n    );\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.instr = null;\r\n    options.export.options = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n  _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(\r\n    exportOptions,\r\n    customLogicOptions.allowFileResources,\r\n    customLogicOptions.allowCodeExecution\r\n  );\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  options.export = {\r\n    ...exportOptions,\r\n    ..._findChartSize(exportOptions)\r\n  };\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `scale` value:\r\n  // - It cannot be lower than 0.1\r\n  // - It cannot be higher than 5.0\r\n  // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Gather `height`, `width` and `scale` information in one object\r\n  const size = { height, width, scale };\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let [param, value] of Object.entries(size)) {\r\n    size[param] =\r\n      typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n  }\r\n\r\n  // Return the size object\r\n  return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n  // In case of allowing code execution\r\n  if (allowCodeExecution) {\r\n    // Process the `resources` option\r\n    if (typeof customLogicOptions.resources === 'string') {\r\n      // Custom stringified resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } else if (!customLogicOptions.resources) {\r\n      try {\r\n        // Load the default one\r\n        customLogicOptions.resources = _handleResources(\r\n          readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n          customLogicOptions.allowFileResources,\r\n          true\r\n        );\r\n      } catch (error) {\r\n        log(2, '[chart] Unable to load the default `resources.json` file.');\r\n      }\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = wrapAround(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = wrapAround(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  let handledResources = resources;\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (allowFileResources && resources.endsWith('.json')) {\r\n    try {\r\n      handledResources = isAllowedConfig(\r\n        readFileSync(getAbsolutePath(resources), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch {\r\n      return null;\r\n    }\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Validate option\r\n  handledResources = validateOption('resources', handledResources);\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n  exportOptions,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled and the app exists\r\n    if (app && rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get and pre-validate the options and store them in the request\r\n    request.validatedOptions = {\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    };\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const requestOptions = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = requestOptions.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(requestOptions, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHighchartsVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  /**\r\n   * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n   */\r\n  app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n    try {\r\n      log(4, '[ui] Returning UI for the export.');\r\n\r\n      response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n        acceptRanges: false\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Compare versions\r\n      const newVersion = request.params.newVersion;\r\n\r\n      // When a correct value found\r\n      if (newVersion) {\r\n        try {\r\n          // Update version\r\n          await updateHighchartsVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHighchartsVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      server: serverOptions\r\n    });\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions({\r\n    server: {\r\n      rateLimiting: rateLimitingOptions\r\n    }\r\n  });\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} initOptions - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration.\r\n */\r\nexport async function initExport(initOptions) {\r\n  // Init, validate and update the options object\r\n  const options = updateOptions(initOptions);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check if cache needs to be updated\r\n  await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        level\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        toConsole\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        dest,\r\n        file,\r\n        toFile\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","normalize","resolve","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initOptions","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","validateOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","async","fetch","url","requestOptions","Promise","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","i","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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C,aAAc,kBAAmB,iBACzC2D,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBC,cAAe,CACbxE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBE,iBAAkB,CAChBzE,MAAO,CAAC,kBACR2D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBG,cAAe,CACb1E,MAAO,CACL,wEACA,kGAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACb1G,KAAM,OACN2G,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN5E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACb1G,KAAM,SAGVwH,MAAO,CACL7E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACb1G,KAAM,SAGVyH,QAAS,CACP9E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACb1G,KAAM,SAGV0H,IAAK,CACH/E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACb1G,KAAM,SAGV2H,MAAO,CACLhF,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,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"} diff --git a/dist/index.esm.js b/dist/index.esm.js index 4b5b4558..8a23a2f7 100644 --- a/dist/index.esm.js +++ b/dist/index.esm.js @@ -1,2 +1,2 @@ -import"colors";import{readFileSync,existsSync,mkdirSync,appendFile,writeFileSync}from"fs";import{isAbsolute,normalize,resolve,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return isAbsolute(e)?normalize(e):resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=z.string().trim().array(),i=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1){return _mergeOptions(getOptions(t),e)}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),i=join(r,"manifest.json"),n=join(r,"sources.js");if(!existsSync(r)&&mkdirSync(r,{recursive:!0}),!existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=updateOptions({highcharts:{version:e}});await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await fetch(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,i){let n;const s=r.host,a=r.port;if(s&&a)try{n=new HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=n?{agent:n,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,i,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,i))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,i=e.cdnUrl||cache.cdnUrl;try{const n={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${i}/${r}/${e}`:`${i}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`))],e.customScripts,t,n),cache.hcVersion=extractVersion(cache.sources),writeFileSync(o,cache.sources),n}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=i(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){let i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:getAbsolutePath(e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=i?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const i=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${i()}ms.`).setError(n);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${i()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);e=validateOptions(e),await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{e=validateOptions(e);const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let i=e,n=!1;if(t&&e.endsWith(".json"))try{i=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else i=isAllowedConfig(e,!1,o),i&&!t&&delete i.files;for(const e in i)r.includes(e)?n||(n=!0):delete i[e];return n?(i.files&&(i.files=i.files.map((e=>e.trim())),(!i.files||i.files.length<=0)&&delete i.files),i=validateOption("resources",i),i):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions=validateOptions({requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}}),o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);let i=e.params.newVersion;try{i=validateOption("version",e.params.newVersion)}catch(e){throw new ExportError(`[version] Version is incorrect: ${e.message}`,400).setError(e)}if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions(validateOptions({server:e}));if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions(validateOptions({server:{rateLimiting:e}}));rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=updateOptions(validateOptions(e));setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions(validateOptions({logging:{level:e}})).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions(validateOptions({logging:{toConsole:e}})).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions(validateOptions({logging:{dest:e,file:t,toFile:o}}));enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};export{index as default,initExport}; +import"colors";import{readFileSync,existsSync,mkdirSync,appendFile,writeFileSync}from"fs";import{isAbsolute,normalize,resolve,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e}`}function fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function getAbsolutePath(e){return isAbsolute(e)?normalize(e):resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}function wrapAround(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?wrapAround(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"",logging.file=t||"")}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}},nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=z.string().trim().array(),i=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setStatus(e){return this.statusCode=e,this}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1,o=!0){return _mergeOptions(getOptions(t),validateOptions(e,o))}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty array.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}async function fetch(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkAndUpdateCache(e,t){try{let o;const r=getCachePath(),i=join(r,"manifest.json"),n=join(r,"sources.js");if(!existsSync(r)&&mkdirSync(r,{recursive:!0}),!existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=extractVersion(cache.sources))}await _saveConfigToManifest(e,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHighchartsVersion(){return cache.hcVersion}async function updateHighchartsVersion(e){const t=updateOptions({highcharts:{version:e}});await checkAndUpdateCache(t.highcharts,t.server.proxy)}function extractVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _fetchAndProcessScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await fetch(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}async function _saveConfigToManifest(e,t={}){const o={version:e.version,modules:t};cache.activeManifest=o,log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(o),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _fetchScripts(e,t,o,r,i){let n;const s=r.host,a=r.port;if(s&&a)try{n=new HttpsProxyAgent({host:s,port:a})}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}const l=n?{agent:n,timeout:r.timeout}:{},c=[...e.map((e=>_fetchAndProcessScript(`${e}`,l,i,!0))),...t.map((e=>_fetchAndProcessScript(`${e}`,l,i))),...o.map((e=>_fetchAndProcessScript(`${e}`,l)))];return(await Promise.all(c)).join(";\n")}async function _updateCache(e,t,o){const r="latest"===e.version?null:`${e.version}`,i=e.cdnUrl||cache.cdnUrl;try{const n={};return log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`),cache.sources=await _fetchScripts([...e.coreScripts.map((e=>r?`${i}/${r}/${e}`:`${i}/${e}`))],[...e.moduleScripts.map((e=>"map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`)),...e.indicatorScripts.map((e=>r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`))],e.customScripts,t,n),cache.hcVersion=extractVersion(cache.sources),writeFileSync(o,cache.sources),n}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=new Function(`return ${e.globalOptions}`)(),p=i(!1,l,a,s),u=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a),c&&r(c),Highcharts[e.constr]("container",p,u);const d=o();for(const e in d)"function"!=typeof d[e]&&delete d[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const template=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){let i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:getAbsolutePath(e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(template,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=i?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(t.scale)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}})),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);const r=getNewDateTime();log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const i=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${i()}ms.`).setError(n);e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${i()}ms.`),pool.release(t);const s=getNewDateTime()-r;return poolStats.timeSpent+=s,poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${s}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.instr=null,t.export.options=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.type=fixType(t.type,t.outfile),t.outfile=fixOutfile(t.type,t.outfile),t.constr=fixConstr(t.constr),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o,o.allowCodeExecution),_handleGlobalAndTheme(t,o.allowFileResources,o.allowCodeExecution),e.export={...t,..._findChartSize(t)},postWork(e)}function _findChartSize(e){const{chart:t,exporting:o}=e.options||isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2),l={height:e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,width:e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,scale:a};for(let[e,t]of Object.entries(l))l[e]="string"==typeof t?+t.replace(/px|%/gi,""):t;return l}function _handleCustomLogic(e,t){if(t){if("string"==typeof e.resources)e.resources=_handleResources(e.resources,e.allowFileResources,!0);else if(!e.resources)try{e.resources=_handleResources(readFileSync(getAbsolutePath("resources.json"),"utf8"),e.allowFileResources,!0)}catch(e){log(2,"[chart] Unable to load the default `resources.json` file.")}try{e.customCode=wrapAround(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=wrapAround(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){const r=["js","css","files"];let i=e,n=!1;if(t&&e.endsWith(".json"))try{i=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o)}catch{return null}else i=isAllowedConfig(e,!1,o),i&&!t&&delete i.files;for(const e in i)r.includes(e)?n||(n=!0):delete i[e];return n?(i.files&&(i.files=i.files.map((e=>e.trim())),(!i.files||i.files.length<=0)&&delete i.files),i=validateOption("resources",i),i):null}function _handleGlobalAndTheme(e,t,o){["globalOptions","themeOptions"].forEach((r=>{try{e[r]&&(t&&"string"==typeof e[r]&&e[r].endsWith(".json")?e[r]=isAllowedConfig(readFileSync(getAbsolutePath(e[r]),"utf8"),!0,o):e[r]=isAllowedConfig(e[r],!0,o),e[r]=validateOption(r,e[r]))}catch(t){logWithStack(2,t,`[chart] The \`${r}\` cannot be loaded.`),e[r]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`Request [${r}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`Request [${r}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions={requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHighchartsVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const i=e.params.newVersion;if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHighchartsVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHighchartsVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=updateOptions(e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkAndUpdateCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};export{index as default,initExport}; //# sourceMappingURL=index.esm.js.map diff --git a/dist/index.esm.js.map b/dist/index.esm.js.map index e26d85c7..4eb4c3b2 100644 --- a/dist/index.esm.js.map +++ b/dist/index.esm.js.map @@ -1 +1 @@ -{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || '';\r\n logging.file = file || '';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or a reference to the global\r\n * options object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `false`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates a copy of the global options object or a reference to the global\r\n * options object, based on the `getCopy` flag.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false) {\r\n // Merge new options to the global options or its copy and return the result\r\n return _mergeOptions(getOptions(getCopy), newOptions);\r\n}\r\n\r\n/**\r\n * Updates the global options with values provided through the CLI, keeping\r\n * the principle of options load priority. This function accepts a `cliArgs`\r\n * array containing arguments from the CLI, which will be validated and applied\r\n * if provided.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n * 2. Values from the command line interface (CLI).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array.} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Validate options from the custom JSON loaded via the `--loadConfig`\r\n const configOptions = strictValidate(_loadConfigFile(cliArgs));\r\n\r\n // Update global options with the values from the `configOptions`\r\n updateOptions(configOptions);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] Custom options from the `loadConfig` option validation error'\r\n );\r\n }\r\n\r\n try {\r\n // Validate options from the CLI\r\n const cliOptions = looseValidate(\r\n _pairArgumentValue(nestedProps, cliArgs)\r\n );\r\n\r\n // Update global options with the values from the `cliOptions`\r\n updateOptions(cliOptions);\r\n } catch (error) {\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n '[validation] CLI options validation error'\r\n );\r\n }\r\n }\r\n\r\n // Return reference to the global options\r\n return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty array.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n .bold.yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from the `./lib/schemas/config.js` file (defaults).\r\n * 2. Values from environment variables (specified in the `.env` file).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n // Init the object for options\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // Set the correct value based on the established priority order\r\n if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n // The environment variables value\r\n options[name] = envs[item.envLink];\r\n } else {\r\n // The value from the config file\r\n options[name] = item.value;\r\n }\r\n } else {\r\n // Create a section in the options\r\n options[name] = _initOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function _mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? _mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n // Get the allow flags for the custom logic check\r\n const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n // Check if the `--loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `--loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `--loadConfig` is present and has a correct value\r\n if (configFileName && allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n updateOptions,\r\n setCliOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Update to the new version\r\n const options = updateOptions({\r\n highcharts: {\r\n version: newVersion\r\n }\r\n });\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = file.startsWith('http') ? false : true;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: getAbsolutePath(cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const result = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport {\r\n isAllowedConfig,\r\n updateOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n isObject,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Validate single export options\r\n options = validateOptions(options);\r\n\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // Validate batch export options\r\n options = validateOptions(options);\r\n\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n try {\r\n // Check if provided options are in an object\r\n if (!isObject(imageOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = updateOptions(\r\n {\r\n export: imageOptions.export,\r\n customLogic: imageOptions.customLogic\r\n },\r\n true\r\n );\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Validate option\r\n handledResources = validateOption('resources', handledResources);\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled and the app exists\r\n if (app && rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig, validateOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Validate the request options and store parsed structure in the request\r\n request.validatedOptions = validateOptions({\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n });\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js';\r\nimport { validateOption } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n let newVersion = request.params.newVersion;\r\n\r\n // Validate the version\r\n try {\r\n newVersion = validateOption('version', request.params.newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version is incorrect: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // When a correct value found\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions, validateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: serverOptions\r\n })\r\n );\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n })\r\n );\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} initOptions - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration.\r\n */\r\nexport async function initExport(initOptions) {\r\n // Init, validate and update the options object\r\n const options = updateOptions(validateOptions(initOptions));\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n level\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions(\r\n validateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n })\r\n );\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","normalize","resolve","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initOptions","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","validateOptions","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","async","fetch","requestOptions","Promise","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","i","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBE,iBAAkB,CAChBzE,MAAO,CAAC,kBACR2D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBG,cAAe,CACb1E,MAAO,CACL,wEACA,kGAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACb1G,KAAM,OACN2G,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN5E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACb1G,KAAM,SAGVwH,MAAO,CACL7E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACb1G,KAAM,SAGVyH,QAAS,CACP9E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACb1G,KAAM,SAGV0H,IAAK,CACH/E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACb1G,KAAM,SAGV2H,MAAO,CACLhF,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACb1G,KAAM,SAGVC,QAAS,CACP0C,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACb1G,KAAM,SAGVA,KAAM,CACJ2C,MAAO,MACP2D,M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"} \ No newline at end of file +{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Adjusts the constructor name by transforming and normalizing it based\r\n * on common chart types.\r\n *\r\n * @function fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be fixed.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nexport function fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Fixes the outfile based on provided type.\r\n *\r\n * @function fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile.\r\n */\r\nexport function fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type}`;\r\n}\r\n\r\n/**\r\n * Fixes the export type based on MIME types and file extensions.\r\n *\r\n * @function fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type.\r\n */\r\nexport function fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function isAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} True if the item is an object, false otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} True if the object is empty, false otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} True if a private IP range URL is found, false otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\n/**\r\n * Wraps custom code to execute it safely.\r\n *\r\n * @function wrapAround\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nexport function wrapAround(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? wrapAround(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean,\r\n wrapAround\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom message\r\n * can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || '';\r\n logging.file = file || '';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array.} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * Provides default configurations that support environment variables, CLI\r\n * arguments, and interactive prompts for customization of options and features.\r\n * Additionally, it maps legacy options to modern structures, generates nested\r\n * argument mappings, and displays CLI usage information.\r\n */\r\n\r\n/**\r\n * The configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option\r\n * - Data types for validation\r\n * - Names of corresponding environment variables\r\n * - Descriptions of each property\r\n * - Information used for prompts in interactive configuration\r\n * - [Optional] Corresponding CLI argument names for CLI usage\r\n * - [Optional] Legacy names from the previous PhantomJS-based server\r\n */\r\nexport const defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\n// Properties nesting level of all options\r\nexport const nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nexport const absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * can be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array.} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array.} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n defaultConfig,\r\n nestedProps,\r\n absoluteProps\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport { defaultConfig } from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets or updates the HTTP status code for the error.\r\n *\r\n * @param {number} statusCode - The HTTP status code to assign to the error.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setStatus(statusCode) {\r\n this.statusCode = statusCode;\r\n\r\n return this;\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n this.error = error;\r\n\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Manages configuration for the Highcharts Export Server by loading\r\n * and merging options from multiple sources, such as default settings,\r\n * environment variables, user-provided options, and command-line arguments.\r\n * Ensures the global options are up-to-date with the highest priority values.\r\n * Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { __dirname, deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport { defaultConfig, absoluteProps, nestedProps } from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or a reference to the global\r\n * options object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `false`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates either a copy of the global options object or a reference\r\n * to the global options object, depending on the getCopy flag, using\r\n * the provided newOptions, which may or may not be validated.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false, strictCheck = true) {\r\n // Merge new options to the global options or its copy and return the result\r\n return _mergeOptions(\r\n // First, get the options\r\n getOptions(getCopy),\r\n // Next, validate the new options\r\n validateOptions(newOptions, strictCheck)\r\n );\r\n}\r\n\r\n/**\r\n * Updates the global options with values provided through the CLI, keeping\r\n * the principle of options load priority. This function accepts a `cliArgs`\r\n * array containing arguments from the CLI, which will be validated and applied\r\n * if provided.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n * 2. Values from the command line interface (CLI).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array.} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Get options from the custom JSON loaded via the `--loadConfig`\r\n const configOptions = _loadConfigFile(cliArgs);\r\n\r\n // Update global options with validated values from the `configOptions`\r\n updateOptions(configOptions);\r\n } catch (error) {\r\n log(2, '[validation] No options added from the `--loadConfig` option.');\r\n }\r\n\r\n try {\r\n // Get options from the CLI\r\n const cliOptions = _pairArgumentValue(nestedProps, cliArgs);\r\n\r\n // Update global options with validated values from the `cliOptions`\r\n updateOptions(cliOptions, false, false);\r\n } catch (error) {\r\n log(2, '[validation] No options added from the CLI arguments.');\r\n }\r\n }\r\n\r\n // Return reference to the global options\r\n return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS) to a new format\r\n * (Puppeteer). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping\r\n * (`nestedProps`). The new format is used for Puppeteer, while the old format\r\n * was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in `nestedProps` or an empty object if the provided\r\n * `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty array.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If true, functions are preserved. Otherwise, when\r\n * a function is found, null is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is true, and null\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return null if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return null if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo, version, and license information.\r\n *\r\n * @function printLicense\r\n */\r\nexport function printLicense() {\r\n // Print the logo and version information\r\n printVersion();\r\n\r\n // Print the license information\r\n console.log(\r\n 'This software requires a valid Highcharts license for commercial use.\\n'\r\n .yellow,\r\n '\\nFor a full list of CLI options, type:',\r\n '\\nhighcharts-export-server --help\\n'.green,\r\n '\\nIf you do not have a license, one can be obtained here:',\r\n '\\nhttps://shop.highsoft.com/\\n'.green,\r\n '\\nTo customize your installation, please refer to the README file at:',\r\n '\\nhttps://github.com/highcharts/node-export-server#readme\\n'.green\r\n );\r\n}\r\n\r\n/**\r\n * Prints usage information for CLI arguments, displaying available options\r\n * and their descriptions. It can list properties recursively if categories\r\n * contain nested options.\r\n *\r\n * @function printUsage\r\n */\r\nexport function printUsage() {\r\n // Display README and general usage information\r\n console.log(\r\n '\\nUsage of CLI arguments:'.bold,\r\n '\\n-----------------------',\r\n `\\nFor more detailed information, visit the README file at: ${'https://github.com/highcharts/node-export-server#readme'.green}.\\n`\r\n );\r\n\r\n // Iterate through each category in the `defaultConfig` and display usage info\r\n Object.keys(defaultConfig).forEach((category) => {\r\n console.log(`${category.toUpperCase()}`.bold.red);\r\n _cycleCategories(defaultConfig[category]);\r\n console.log('');\r\n });\r\n}\r\n\r\n/**\r\n * Prints the Highcharts Export Server logo or text with the version\r\n * information.\r\n *\r\n * @function printVersion\r\n *\r\n * @param {boolean} [noLogo=false] - If true, only prints text with the version\r\n * information, without the logo. The default value is `false`.\r\n */\r\nexport function printVersion(noLogo = false) {\r\n // Get package version either from `.env` or from `package.json`\r\n const packageVersion = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n ).version;\r\n\r\n // Print text only\r\n if (noLogo) {\r\n console.log(`Highcharts Export Server v${packageVersion}`);\r\n } else {\r\n // Print the logo\r\n console.log(\r\n readFileSync(join(__dirname, 'msg', 'startup.msg'), 'utf8').toString()\r\n .bold.yellow,\r\n `v${packageVersion}\\n`.bold\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The priority order for setting values is:\r\n *\r\n * 1. Values from the `./lib/schemas/config.js` file (defaults).\r\n * 2. Values from environment variables (specified in the `.env` file).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n // Init the object for options\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // Set the correct value based on the established priority order\r\n if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n // The environment variables value\r\n options[name] = envs[item.envLink];\r\n } else {\r\n // The value from the config file\r\n options[name] = item.value;\r\n }\r\n } else {\r\n // Create a section in the options\r\n options[name] = _initOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Merges two sets of configuration options, considering absolute properties.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - Original configuration options.\r\n * @param {Object} newOptions - New configuration options to be merged.\r\n *\r\n * @returns {Object} Merged configuration options.\r\n */\r\nexport function _mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? _mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON-formatted string\r\n * with the option to preserve functions. In order for a function\r\n * to be preserved, it needs to follow the format `function (...) {...}`.\r\n * Such a function can also be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to true, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to true, functions are saved\r\n * as strings. The `allowFunctions` must be set to true as well for this to take\r\n * an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nexport function _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If value is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If allowFunctions is set to true, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array.} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n // Get the allow flags for the custom logic check\r\n const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n // Check if the `--loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `--loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `--loadConfig` is present and has a correct value\r\n if (configFileName && allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array.} nestedProps - An array of nesting level for all\r\n * options.\r\n * @param {Array.} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(nestedProps, cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively traverses the options object to print the usage information\r\n * for each option category and individual option.\r\n *\r\n * @function _cycleCategories\r\n *\r\n * @param {Object} options - The options object containing CLI options. It may\r\n * include nested categories and individual options.\r\n */\r\nfunction _cycleCategories(options) {\r\n for (const [name, option] of Object.entries(options)) {\r\n // If the current entry is a category and not a leaf option, recurse into it\r\n if (!Object.prototype.hasOwnProperty.call(option, 'value')) {\r\n _cycleCategories(option);\r\n } else {\r\n // Prepare description\r\n const descName = ` --${option.cliName || name}`;\r\n\r\n // Get the value\r\n let optionValue = option.value;\r\n\r\n // Prepare value for option that is not null and is array of strings\r\n if (optionValue !== null && option.types.includes('string[]')) {\r\n optionValue =\r\n '[' + optionValue.map((item) => `'${item}'`).join(', ') + ']';\r\n }\r\n\r\n // Prepare value for option that is not null and is a string\r\n if (optionValue !== null && option.types.includes('string')) {\r\n optionValue = `'${optionValue}'`;\r\n }\r\n\r\n // Display correctly aligned messages\r\n console.log(\r\n descName.green,\r\n `${('<' + option.types.join('|') + '>').yellow}`,\r\n `${String(optionValue).bold}`.blue,\r\n `- ${option.description}.`\r\n );\r\n }\r\n }\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n updateOptions,\r\n setCliOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig,\r\n printLicense,\r\n printUsage,\r\n printVersion\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Fetches data from the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function fetch\r\n *\r\n * @param {string} url - The URL to fetch data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function fetch(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with requestOptions\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (http or https).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n fetch,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { fetch } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkAndUpdateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkAndUpdateCache(\r\n highchartsOptions,\r\n serverProxyOptions\r\n) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules.\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHighchartsVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHighchartsVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the new version.\r\n *\r\n * @async\r\n * @function updateHighchartsVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHighchartsVersion(newVersion) {\r\n // Update to the new version\r\n const options = updateOptions({\r\n highcharts: {\r\n version: newVersion\r\n }\r\n });\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function extractVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nexport function extractVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the scriptPath.\r\n *\r\n * @function extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nexport function extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchAndProcessScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional options for the proxy agent\r\n * to use for a request.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchAndProcessScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await fetch(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which Highcharts\r\n * modules have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(highchartsOptions, fetchedModules = {}) {\r\n const newManifest = {\r\n version: highchartsOptions.version,\r\n modules: fetchedModules\r\n };\r\n\r\n // Update cache object with the current modules\r\n cache.activeManifest = newManifest;\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(newManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches Highcharts `scripts` and `customScripts` from the given CDNs.\r\n *\r\n * @async\r\n * @function _fetchScripts\r\n *\r\n * @param {Array.} coreScripts - Highcharts core scripts to fetch.\r\n * @param {Array.} moduleScripts - Highcharts modules to fetch.\r\n * @param {Array.} customScripts - Custom script paths to fetch (full\r\n * URLs).\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n *\r\n * @returns {Promise} A Promise that resolves to the fetched scripts\r\n * content joined.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * setting an HTTP Agent for proxy.\r\n */\r\nasync function _fetchScripts(\r\n coreScripts,\r\n moduleScripts,\r\n customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n) {\r\n // Configure proxy if exists\r\n let proxyAgent;\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a Proxy Agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // If exists, add proxy agent to request options\r\n const requestOptions = proxyAgent\r\n ? {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n }\r\n : {};\r\n\r\n const allFetchPromises = [\r\n ...coreScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules, true)\r\n ),\r\n ...moduleScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions, fetchedModules)\r\n ),\r\n ...customScripts.map((script) =>\r\n _fetchAndProcessScript(`${script}`, requestOptions)\r\n )\r\n ];\r\n\r\n const fetchedScripts = await Promise.all(allFetchPromises);\r\n return fetchedScripts.join(';\\n');\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts and their versions.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n try {\r\n const fetchedModules = {};\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n cache.sources = await _fetchScripts(\r\n [\r\n ...highchartsOptions.coreScripts.map((c) =>\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${c}` : `${cdnUrl}/${c}`\r\n )\r\n ],\r\n [\r\n ...highchartsOptions.moduleScripts.map((m) =>\r\n m === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/maps/modules/${m}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${m}`\r\n : `${cdnUrl}/modules/${m}`\r\n ),\r\n ...highchartsOptions.indicatorScripts.map((i) =>\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${i}`\r\n : `${cdnUrl}/stock/indicators/${i}`\r\n )\r\n ],\r\n highchartsOptions.customScripts,\r\n serverProxyOptions,\r\n fetchedModules\r\n );\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = extractVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\nexport default {\r\n checkAndUpdateCache,\r\n getHighchartsVersion,\r\n updateHighchartsVersion,\r\n extractVersion,\r\n extractModuleName,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that resources are correctly managed and can handle failures during\r\n * operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst template = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n\r\n const open = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await open();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n await open();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer Page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If true, navigates to `about:blank` and resets content\r\n * and scripts. If false, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to true when page\r\n * is correctly cleared and false when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer Page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use resources\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = file.startsWith('http') ? false : true;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n let cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: getAbsolutePath(cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array.} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer Page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(template, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer Page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(exportOptions.scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array.} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n // Save the start time\r\n const workStart = getNewDateTime();\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const result = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (result instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // NOTE:\r\n // Only page.screenshot will throw this, timeouts for PDF's are\r\n // handled by the page.pdf function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (result.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n result.name === 'TimeoutError' ||\r\n result.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(result);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(result);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Used for statistics in averageTime and processedWorkCount, which\r\n // in turn is used by the /health route.\r\n const workEnd = getNewDateTime();\r\n const exportTime = workEnd - workStart;\r\n\r\n poolStats.timeSpent += exportTime;\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportTime}ms.`);\r\n\r\n // Otherwise return the result\r\n return {\r\n result,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or null\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function getPoolInfo\r\n */\r\nexport function getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`,\r\n * and `destroy` functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a TargetCloseError, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfo,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions to prepare for the exporting charts\r\n * into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { isAllowedConfig, updateOptions, validateOption } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport {\r\n fixConstr,\r\n fixOutfile,\r\n fixType,\r\n getAbsolutePath,\r\n getBase64,\r\n isObject,\r\n roundNumber,\r\n wrapAround\r\n} from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n try {\r\n // Check if provided options are in an object\r\n if (!isObject(imageOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = updateOptions(\r\n {\r\n export: imageOptions.export,\r\n customLogic: imageOptions.customLogic\r\n },\r\n true\r\n );\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.instr = null;\r\n options.export.options = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = fixOutfile(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = fixConstr(exportOptions.constr);\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the custom logic options (`customCode`, `callback`, `resources`)\r\n _handleCustomLogic(customLogicOptions, customLogicOptions.allowCodeExecution);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(\r\n exportOptions,\r\n customLogicOptions.allowFileResources,\r\n customLogicOptions.allowCodeExecution\r\n );\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n options.export = {\r\n ...exportOptions,\r\n ..._findChartSize(exportOptions)\r\n };\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Calculates the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _findChartSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n *\r\n * @returns {Object} The object containing calculated `height`, `width`\r\n * and `scale` values for the chart export.\r\n */\r\nfunction _findChartSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n exportOptions.options || isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `scale` value:\r\n // - It cannot be lower than 0.1\r\n // - It cannot be higher than 5.0\r\n // - It must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Gather `height`, `width` and `scale` information in one object\r\n const size = { height, width, scale };\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let [param, value] of Object.entries(size)) {\r\n size[param] =\r\n typeof value === 'string' ? +value.replace(/px|%/gi, '') : value;\r\n }\r\n\r\n // Return the size object\r\n return size;\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions, allowCodeExecution) {\r\n // In case of allowing code execution\r\n if (allowCodeExecution) {\r\n // Process the `resources` option\r\n if (typeof customLogicOptions.resources === 'string') {\r\n // Custom stringified resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } else if (!customLogicOptions.resources) {\r\n try {\r\n // Load the default one\r\n customLogicOptions.resources = _handleResources(\r\n readFileSync(getAbsolutePath('resources.json'), 'utf8'),\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] Unable to load the default `resources.json` file.');\r\n }\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = wrapAround(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = wrapAround(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n let handledResources = resources;\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (allowFileResources && resources.endsWith('.json')) {\r\n try {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch {\r\n return null;\r\n }\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Validate option\r\n handledResources = validateOption('resources', handledResources);\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is true), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to null. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to null.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n */\r\nfunction _handleGlobalAndTheme(\r\n exportOptions,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed. This can be useful\r\n * in applications where proper resource management and clean shutdown of timers\r\n * are critical to avoid memory leaks or unintended behavior.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled and the app exists\r\n if (app && rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `Request [${requestId}] - [validation] SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get and pre-validate the options and store them in the request\r\n request.validatedOptions = {\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n };\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const requestOptions = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = requestOptions.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(requestOptions, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHighchartsVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: HIGHCHARTS_ADMIN_TOKEN is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Compare versions\r\n const newVersion = request.params.newVersion;\r\n\r\n // When a correct value found\r\n if (newVersion) {\r\n try {\r\n // Update version\r\n await updateHighchartsVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHighchartsVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middleware setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: serverOptions\r\n });\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array.} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n });\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Core module for initializing and managing the Highcharts Export\r\n * Server. Provides functionalities for configuring exports, setting up server\r\n * operations, logging, scripts caching, resource pooling, and graceful process\r\n * cleanup.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkAndUpdateCache } from './cache.js';\r\nimport {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} initOptions - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration.\r\n */\r\nexport async function initExport(initOptions) {\r\n // Init, validate and update the options object\r\n const options = updateOptions(initOptions);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check if cache needs to be updated\r\n await checkAndUpdateCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM'\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n level\r\n }\r\n });\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n });\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n });\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","fixConstr","constr","fixedConstr","toLowerCase","replace","includes","fixOutfile","type","outfile","getAbsolutePath","split","shift","fixType","mimeTypes","formats","values","outType","pop","find","t","path","isAbsolute","normalize","resolve","getBase64","input","Buffer","from","toString","getNewDate","Date","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","wrapAround","customCode","allowFileResources","isCallback","endsWith","readFileSync","startsWith","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","hint","choices","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","config","propChain","forEach","entry","substring","dotenv","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","nullable","string","refine","params","errorMessage","stringArray","filterCallback","arraySchema","array","stringSchema","slice","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","index","ExportError","Error","constructor","statusCode","super","setStatus","setError","name","_initOptions","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","validateOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","async","fetch","requestOptions","Promise","reject","_getProtocolModule","get","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkAndUpdateCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","modules","moduleMap","m","numberOfModules","moduleName","extractVersion","_saveConfigToManifest","getHighchartsVersion","updateHighchartsVersion","newVersion","cacheSources","extractModuleName","scriptPath","_fetchAndProcessScript","script","shouldThrowError","newManifest","writeFileSync","_fetchScripts","proxyAgent","HttpsProxyAgent","agent","allFetchPromises","all","c","i","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","defaultOptions","template","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","open","launch","setTimeout","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","document","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","svgElement","querySelector","chartHeight","baseVal","chartWidth","style","zoom","margin","parseFloat","x","y","_getClipRegion","viewportHeight","abs","ceil","viewportWidth","result","setViewport","deviceScaleFactor","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","outerHTML","clip","race","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","getPoolInfo","acquireCounter","workStart","exportCounter","exportTime","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_handleCustomLogic","_handleGlobalAndTheme","_findChartSize","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","allowedProps","handledResources","correctResources","propName","optionsName","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","toFixed","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBE,iBAAkB,CAChBzE,MAAO,CAAC,kBACR2D,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACb1G,KAAM,cACNkH,aAAc,0DAGlBG,cAAe,CACb1E,MAAO,CACL,wEACA,kGAEF2D,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACb1G,KAAM,OACN2G,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACN5E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACb1G,KAAM,SAGVwH,MAAO,CACL7E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACb1G,KAAM,SAGVyH,QAAS,CACP9E,MAAO,KACP2D,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACb1G,KAAM,SAGV0H,IAAK,CACH/E,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACb1G,KAAM,SAGV2H,MAAO,CACLhF,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACb1G,KAAM,SAGVC,QAAS,CACP0C,MAAO,KACP2D,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACb1G,KAAM,SAGVA,KAAM,CACJ2C,MAAO,MACP2D,M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"} \ No newline at end of file diff --git a/lib/chart.js b/lib/chart.js index 46fe52b5..c9849c09 100644 --- a/lib/chart.js +++ b/lib/chart.js @@ -21,12 +21,7 @@ See LICENSE file in root for details. import { readFileSync, writeFileSync } from 'fs'; -import { - isAllowedConfig, - updateOptions, - validateOption, - validateOptions -} from './config.js'; +import { isAllowedConfig, updateOptions, validateOption } from './config.js'; import { log, logWithStack } from './logger.js'; import { getPoolStats, killPool, postWork } from './pool.js'; import { sanitize } from './sanitize.js'; @@ -68,9 +63,6 @@ let allowCodeExecution = false; export async function singleExport(options) { // Check if the export makes sense if (options && options.export) { - // Validate single export options - options = validateOptions(options); - // Perform an export await startExport( { export: options.export, customLogic: options.customLogic }, @@ -140,9 +132,6 @@ export async function singleExport(options) { export async function batchExport(options) { // Check if the export makes sense if (options && options.export && options.export.batch) { - // Validate batch export options - options = validateOptions(options); - // An array for collecting batch exports const batchFunctions = []; diff --git a/lib/config.js b/lib/config.js index e3613cad..cc0ea7e7 100644 --- a/lib/config.js +++ b/lib/config.js @@ -57,8 +57,9 @@ export function getOptions(getCopy = true) { } /** - * Updates a copy of the global options object or a reference to the global - * options object, based on the `getCopy` flag. + * Updates either a copy of the global options object or a reference + * to the global options object, depending on the getCopy flag, using + * the provided newOptions, which may or may not be validated. * * @function updateOptions * @@ -67,13 +68,20 @@ export function getOptions(getCopy = true) { * @param {boolean} [getCopy=false] - Determines whether to merge the new * options into a copy of the global options object (`true`) or directly into * the global options object (`false`). The default value is `false`. + * @param {boolean} [strictCheck=true] - Determines if stricter validation + * should be applied. The default value is `true`. * * @returns {Object} The updated options object, either the modified global * options or a modified copy, based on the value of `getCopy`. */ -export function updateOptions(newOptions, getCopy = false) { +export function updateOptions(newOptions, getCopy = false, strictCheck = true) { // Merge new options to the global options or its copy and return the result - return _mergeOptions(getOptions(getCopy), newOptions); + return _mergeOptions( + // First, get the options + getOptions(getCopy), + // Next, validate the new options + validateOptions(newOptions, strictCheck) + ); } /** @@ -99,33 +107,23 @@ export function setCliOptions(cliArgs) { // Only for the CLI usage if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) { try { - // Validate options from the custom JSON loaded via the `--loadConfig` - const configOptions = strictValidate(_loadConfigFile(cliArgs)); + // Get options from the custom JSON loaded via the `--loadConfig` + const configOptions = _loadConfigFile(cliArgs); - // Update global options with the values from the `configOptions` + // Update global options with validated values from the `configOptions` updateOptions(configOptions); } catch (error) { - logZodIssues( - 1, - error.issues, - '[validation] Custom options from the `loadConfig` option validation error' - ); + log(2, '[validation] No options added from the `--loadConfig` option.'); } try { - // Validate options from the CLI - const cliOptions = looseValidate( - _pairArgumentValue(nestedProps, cliArgs) - ); + // Get options from the CLI + const cliOptions = _pairArgumentValue(nestedProps, cliArgs); - // Update global options with the values from the `cliOptions` - updateOptions(cliOptions); + // Update global options with validated values from the `cliOptions` + updateOptions(cliOptions, false, false); } catch (error) { - logZodIssues( - 1, - error.issues, - '[validation] CLI options validation error' - ); + log(2, '[validation] No options added from the CLI arguments.'); } } diff --git a/lib/index.js b/lib/index.js index 3cea1550..d59ccd8d 100644 --- a/lib/index.js +++ b/lib/index.js @@ -66,7 +66,7 @@ import server from './server/server.js'; */ export async function initExport(initOptions) { // Init, validate and update the options object - const options = updateOptions(validateOptions(initOptions)); + const options = updateOptions(initOptions); // Set the `allowCodeExecution` per export module scope setAllowCodeExecution(options.customLogic.allowCodeExecution); @@ -155,41 +155,35 @@ export default { logZodIssues, setLogLevel: function (level) { // Update the instance options object - const options = updateOptions( - validateOptions({ - logging: { - level - } - }) - ); + const options = updateOptions({ + logging: { + level + } + }); // Call the function setLogLevel(options.logging.level); }, enableConsoleLogging: function (toConsole) { // Update the instance options object - const options = updateOptions( - validateOptions({ - logging: { - toConsole - } - }) - ); + const options = updateOptions({ + logging: { + toConsole + } + }); // Call the function enableConsoleLogging(options.logging.toConsole); }, enableFileLogging: function (dest, file, toFile) { // Update the instance options object - const options = updateOptions( - validateOptions({ - logging: { - dest, - file, - toFile - } - }) - ); + const options = updateOptions({ + logging: { + dest, + file, + toFile + } + }); // Call the function enableFileLogging( diff --git a/lib/server/middlewares/validation.js b/lib/server/middlewares/validation.js index 551d1337..c451e9de 100644 --- a/lib/server/middlewares/validation.js +++ b/lib/server/middlewares/validation.js @@ -26,7 +26,7 @@ See LICENSE file in root for details. import { v4 as uuid } from 'uuid'; import { getAllowCodeExecution } from '../../chart.js'; -import { isAllowedConfig, validateOptions } from '../../config.js'; +import { isAllowedConfig } from '../../config.js'; import { log } from '../../logger.js'; import { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js'; @@ -146,8 +146,8 @@ function requestBodyMiddleware(request, response, next) { ); } - // Validate the request options and store parsed structure in the request - request.validatedOptions = validateOptions({ + // Get and pre-validate the options and store them in the request + request.validatedOptions = { // Set the created ID as a `requestId` property in the options requestId, export: { @@ -181,7 +181,7 @@ function requestBodyMiddleware(request, response, next) { callback: body.callback, resources: isAllowedConfig(body.resources, true, allowCodeExecution) } - }); + }; // Call the next middleware return next(); diff --git a/lib/server/routes/versionChange.js b/lib/server/routes/versionChange.js index d5db30f9..16f3adc5 100644 --- a/lib/server/routes/versionChange.js +++ b/lib/server/routes/versionChange.js @@ -18,7 +18,6 @@ See LICENSE file in root for details. */ import { getHighchartsVersion, updateHighchartsVersion } from '../../cache.js'; -import { validateOption } from '../../config.js'; import { log } from '../../logger.js'; import { envs } from '../../validation.js'; @@ -63,17 +62,7 @@ export default function versionChangeRoutes(app) { } // Compare versions - let newVersion = request.params.newVersion; - - // Validate the version - try { - newVersion = validateOption('version', request.params.newVersion); - } catch (error) { - throw new ExportError( - `[version] Version is incorrect: ${error.message}`, - 400 - ).setError(error); - } + const newVersion = request.params.newVersion; // When a correct value found if (newVersion) { diff --git a/lib/server/server.js b/lib/server/server.js index 36f0a486..3a07e0b4 100644 --- a/lib/server/server.js +++ b/lib/server/server.js @@ -30,7 +30,7 @@ import http from 'http'; import https from 'https'; import multer from 'multer'; -import { updateOptions, validateOptions } from '../config.js'; +import { updateOptions } from '../config.js'; import { log, logWithStack } from '../logger.js'; import { __dirname, getAbsolutePath } from '../utils.js'; @@ -74,11 +74,9 @@ const app = express(); export async function startServer(serverOptions) { try { // Update the instance options object - const options = updateOptions( - validateOptions({ - server: serverOptions - }) - ); + const options = updateOptions({ + server: serverOptions + }); // Use validated options serverOptions = options.server; @@ -295,13 +293,11 @@ export function getApp() { */ export function enableRateLimiting(rateLimitingOptions) { // Update the instance options object - const options = updateOptions( - validateOptions({ - server: { - rateLimiting: rateLimitingOptions - } - }) - ); + const options = updateOptions({ + server: { + rateLimiting: rateLimitingOptions + } + }); // Set the rate limiting options rateLimitingMiddleware(app, options.server.rateLimitingOptions); From c22eeba5eed974fe57438e56a1c74e3e2c1331f7 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Mon, 3 Feb 2025 01:45:11 +0100 Subject: [PATCH 17/19] Small validation correction after merge. --- README.md | 4 ++-- dist/index.cjs | 4 ++-- dist/index.esm.js | 2 +- dist/index.esm.js.map | 2 +- lib/chart.js | 9 ++++++--- lib/index.js | 7 ++++--- lib/server/server.js | 11 ++++++----- 7 files changed, 22 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 5f0fa2d7..cbe764db 100644 --- a/README.md +++ b/README.md @@ -723,9 +723,9 @@ This package supports both CommonJS and ES modules. **highcharts-export-server module** -- `async function startServer(serverOptions)`: Starts an HTTP and/or HTTPS server based on the provided configuration. The `serverOptions` object contains server-related properties (refer to the `server` section in the `./lib/schemas/config.js` file for details). +- `async function startServer(serverOptions = {})`: Starts an HTTP and/or HTTPS server based on the provided configuration. The `serverOptions` object contains server-related properties (refer to the `server` section in the `./lib/schemas/config.js` file for details). - - `@param {Object} serverOptions` - The configuration object containing `server` options. This object may include a partial or complete set of the `server` options. If the options are partial, missing values will default to the current global configuration. + - `@param {Object} [serverOptions={}]` - The configuration object containing `server` options. This object may include a partial or complete set of the `server` options. If the options are partial, missing values will default to the current global configuration. The default value is an empty object. - `@returns {Promise}` A Promise that resolves when the server is either not enabled or no valid Express app is found, signaling the end of the function's execution. diff --git a/dist/index.cjs b/dist/index.cjs index 38c96478..5ca5bb1c 100644 --- a/dist/index.cjs +++ b/dist/index.cjs @@ -1,2 +1,2 @@ -"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function getAbsolutePath(e){return path.isAbsolute(e)?path.normalize(e):path.resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:n}=logging;if(5!==t&&(0===t||t>n||n>r.length))return;const i=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:n,levelsDesc:i}=logging;if(0===e||e>n||n>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:n,toFile:i}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(n),enableFileLogging(o,r,i)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"log",logging.file=t||"highcharts-export-server.log")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}};dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),n=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(i):zod.z.union([n,r]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>zod.z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig),nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1,o=!0){return _mergeOptions(getOptions(t),validateOptions(e,o))}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,n)=>t[o]=e.length-1===n?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty object.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const n=e[r];void 0===n.value?_createNestedProps(n,t,`${o}.${r}`):(t[n.cliName||r]=`${o}.${r}`.substring(1),void 0!==n.legacyName&&(t[n.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}async function get$1(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkCache(e,t){try{let o;const r=getCachePath(),n=path.join(r,"manifest.json"),i=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(n)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let r=!1;const s=JSON.parse(fs.readFileSync(n),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=_extractHcVersion(cache.sources))}await _saveConfigToManifest(e.version,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHcVersion(){return cache.hcVersion}async function updateHcVersion(e){const t=updateOptions({highcharts:{version:e}});await checkCache(t.highcharts,t.server.proxy)}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _saveConfigToManifest(e,t={}){cache.activeManifest={version:e,modules:t},log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(cache.activeManifest),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _updateCache(e,t,o){try{const r="latest"===e.version?null:`${e.version}`;log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`);const n=e.cdnUrl||cache.cdnUrl,i=_configureRequest(t),s={};return cache.sources=(await Promise.all([...e.coreScripts.map((e=>_fetchScript(r?`${n}/${r}/${e}`:`${n}/${e}`,i,s,!0))),...e.moduleScripts.map((e=>_fetchScript("map"===e?r?`${n}/maps/${r}/modules/${e}`:`${n}/maps/modules/${e}`:r?`${n}/${r}/modules/${e}`:`${n}/modules/${e}`,i,s))),...e.indicatorScripts.map((e=>_fetchScript(r?`${n}/stock/${r}/indicators/${e}`:`${n}/stock/indicators/${e}`,i,s))),...e.customScripts.map((e=>_fetchScript(`${e}`,i)))])).join(";\n"),cache.hcVersion=_extractHcVersion(cache.sources),fs.writeFileSync(o,cache.sources),s}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}async function _fetchScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const n=await get$1(`${e}.js`,t);if(200===n.statusCode&&"string"==typeof n.text){if(o){o[_extractModuleName(e)]=1}return n.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${n.statusCode}).`,404).setError(n);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}function _configureRequest(e){const t=e.host,o=e.port;if(t&&o)try{return{agent:new httpsProxyAgent.HttpsProxyAgent({host:t,port:o}),timeout:e.timeout}}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}return{}}function _extractHcVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function _extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:n,wrap:i}=Highcharts;Highcharts.setOptionsObj=n(!1,{},o()),window.isRenderComplete=!1,i(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=n(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),i(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=n(!1,l,a,s),p=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a);const u=new Function(`return ${e.globalOptions}`)();u&&r(u),Highcharts[e.constr]("container",c,p);const d=Array.from(document.querySelectorAll(".highcharts-container image"));await Promise.race([Promise.all(d.map((e=>e.complete&&0!==e.naturalHeight?Promise.resolve():new Promise((t=>e.addEventListener("load",t,{once:!0})))))),new Promise((e=>setTimeout(e,2e3)))]);const g=o();for(const e in g)"function"!=typeof g[e]&&delete g[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const pageTemplate=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...n}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&n};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to launch and get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const n=[];if(r.js&&n.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");n.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of n)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}n.length=0;const i=[];if(r.css){const n=r.css.match(/@import\s*([^;]*);/g);if(n)for(let e of n)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:getAbsolutePath(e)}));i.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(pageTemplate,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let n=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;n=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const i=await _getChartSize(e,n,t.scale),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||t.height)),c=Math.abs(Math.ceil(i.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:n?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:n}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(n>1?n:500)}}))}async function _getChartSize(e,t,o){return t?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(o)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&_getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${r()}ms.`).setError(n);return e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t),poolStats.timeSpent+=r(),poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${r()}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function _getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:n,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${n}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r||`chart.${n}`,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.options=null,t.export.instr=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.options=null,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.constr=_fixConstr(t.constr),t.type=_fixType(t.type,t.outfile),t.outfile=_fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o),_handleGlobalAndTheme(t,o),_handleSize(t),_checkDataSize({export:t,customLogic:o}),postWork(e)}function _fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function _fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e||"png"}`}function _fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function _handleSize(e){const{chart:t,exporting:o}=isAllowedConfig(e.instr)||!1,{chart:r,exporting:n}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=e.height||o?.sourceHeight||t?.height||n?.sourceHeight||r?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,l=e.width||o?.sourceWidth||t?.width||n?.sourceWidth||r?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,c=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||n?.scale||s?.scale||e.defaultScale||1,5)),2);e.height=a,e.width=l,e.scale=c;for(let t of["height","width","scale"])"string"==typeof e[t]&&(e[t]=+e[t].replace(/px|%/gi,""))}function _handleCustomLogic(e){if(e.allowCodeExecution){try{e.resources=_handleResources(e.resources,e.allowFileResources,!0)}catch(t){log(2,"[chart] The `resources` cannot be loaded."),e.resources=null}try{e.customCode=_handleCustomCode(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=_handleCustomCode(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){let r=e;r||(e="resources.json");const n=["js","css","files"];let i=!1;t&&"string"==typeof e&&e.endsWith(".json")?r=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o):(r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files);for(const e in r)n.includes(e)?i||(i=!0):delete r[e];return i?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r=validateOption("resources",r),r):null}function _handleCustomCode(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?_handleCustomCode(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}function _handleGlobalAndTheme(e,t){const{allowFileResources:o,allowCodeExecution:r}=t;["globalOptions","themeOptions"].forEach((t=>{try{e[t]&&(o&&"string"==typeof e[t]&&e[t].endsWith(".json")?e[t]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[t]),"utf8"),!0,r):e[t]=isAllowedConfig(e[t],!0,r),e[t]=validateOption(t,e[t]))}catch(o){logWithStack(2,o,`[chart] The \`${t}\` cannot be loaded.`),e[t]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}function _checkDataSize(e){const t=Buffer.byteLength(JSON.stringify(e),"utf-8");if(log(3,`[chart] The current total size of the data for the export process is around ${(t/1048576).toFixed(2)}MB.`),t>=104857600)throw new ExportError("[chart] The data for the export process exceeds 100MB limit.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:n,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:n,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const n=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(n),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const n=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,n);if(null===i&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`[validation] Request [${r}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`[validation] Request [${r}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions={requestId:r,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,n),themeOptions:isAllowedConfig(t.themeOptions,!0,n)},customLogic:{allowCodeExecution:n,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,n)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const n=e.validatedOptions,i=n.requestId;log(4,`[export] Request [${i}] - Got an incoming HTTP request.`),await startExport(n,((n,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(n)throw n;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${i}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:n,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),n||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHcVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){getOptions().ui.enable&&e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const n=e.params.newVersion;if(!n)throw new ExportError("[version] No new version supplied.",400);try{await updateHcVersion(n)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHcVersion(),message:`Successfully updated Highcharts to version: ${n}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),n=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(n.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=updateOptions(e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code: ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};exports.default=index,exports.initExport=initExport; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function getAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an object, `false`\r\n * otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an empty object, `false`\r\n * otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} Returns `true` if a private IP range URL is found, `false`\r\n * otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || 'log';\r\n    logging.file = file || 'highcharts-export-server.log';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * It provides a default configuration object with predefined default values,\r\n * descriptions, and characteristics for each option used in the Export Server.\r\n */\r\n\r\n/**\r\n * The default configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option.\r\n * - Data types for validation.\r\n * - Names of corresponding environment variables.\r\n * - Descriptions of each property.\r\n * - Information used for prompts in interactive configuration.\r\n * - [Optional] Corresponding CLI argument names for CLI usage.\r\n * - [Optional] Legacy names from the previous PhantomJS-based server.\r\n */\r\nconst defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\nexport default defaultConfig;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    // Set the `message` and `stackMessage` with provided message\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    // Set the `statusCode` if provided\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    // Save the provided error\r\n    this.error = error;\r\n\r\n    // Set the error's name if present\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    // Set the error's status code if present\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    // Set the error's stack and stack's message if present\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    // Return updated `ExportError` instance\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module manages configuration for the Highcharts Export Server\r\n * by loading and merging options from multiple sources, such as the default\r\n * settings, environment variables, user-provided options, and command-line\r\n * arguments. Ensures the global options are up-to-date with the highest\r\n * priority values. Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n// Properties nesting level of all options\r\nconst nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nconst absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or an original global options\r\n * object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `true`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n  // Return a copy or an original global options object\r\n  return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object or a copy of the global options\r\n * object, based on the `getCopy` flag. The `newOptions` object can be\r\n * strictly validated depending on the `strictCheck` flag.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false, strictCheck = true) {\r\n  // Merge new options to the global options or its copy and return the result\r\n  return _mergeOptions(\r\n    // First, get the options\r\n    getOptions(getCopy),\r\n    // Next, validate the new options\r\n    validateOptions(newOptions, strictCheck)\r\n  );\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object with values provided through\r\n * the CLI, keeping the principle of options load priority. The function accepts\r\n * a `cliArgs` array containing arguments from the CLI, which will be validated\r\n * and applied if provided.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from the command line interface (CLI).\r\n * 2. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array<string>} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Get options from the custom JSON loaded via the `--loadConfig`\r\n      const configOptions = _loadConfigFile(cliArgs);\r\n\r\n      // Update global options with validated values from the `configOptions`\r\n      updateOptions(configOptions);\r\n    } catch (error) {\r\n      log(2, '[validation] No options added from the `--loadConfig` option.');\r\n    }\r\n\r\n    try {\r\n      // Get options from the CLI\r\n      const cliOptions = _pairArgumentValue(cliArgs);\r\n\r\n      // Update global options with validated values from the `cliOptions`\r\n      updateOptions(cliOptions, false, false);\r\n    } catch (error) {\r\n      log(2, '[validation] No options added from the CLI arguments.');\r\n    }\r\n  }\r\n\r\n  // Return reference to the global options\r\n  return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS-based) to a new format\r\n * (Puppeteer-based). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping provided\r\n * in the `nestedProps` object. The new format is used for Puppeteer, while\r\n * the old format was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in the `nestedProps` object or an empty object\r\n * if the provided `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty object.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If `true`, functions are preserved. Otherwise, when\r\n * a function is found, `null` is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is `true`, and `null`\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return `null` if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return `null` if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from environment variables (specified in the `.env` file).\r\n * 2. Values from the `./lib/schemas/config.js` file (defaults).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n  // Init the object for options\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // Set the correct value based on the established priority order\r\n      if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n        // The environment variables value\r\n        options[name] = envs[item.envLink];\r\n      } else {\r\n        // The value from the config file\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      // Create a category of options in the `options` object\r\n      options[name] = _initOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Recursively merges two sets of configuration options, taking into account\r\n * properties specified in the `absoluteProps` array that require absolute\r\n * merging. The `originalOptions` object will be extended with options from\r\n * the `newOptions` object.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - The original configuration options object\r\n * to be extended.\r\n * @param {Object} newOptions - The new configuration options object to merge.\r\n *\r\n * @returns {Object} The extended `originalOptions` object.\r\n */\r\nfunction _mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? _mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON string with the option\r\n * to preserve functions. In order for a function to be preserved, it needs\r\n * to follow the format `function (...) {...}`. Such a function can also\r\n * be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to `true`, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to `true`, functions are saved\r\n * as strings. The `allowFunctions` must be set to `true` as well for this\r\n * to take an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nfunction _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If `value` is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If the `allowFunctions` is set to `true`, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array<string>} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n  // Get the allow flags for the custom logic check\r\n  const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n  // Check if the `--loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `--loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `--loadConfig` is present and has a correct value\r\n  if (configFileName && allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings in the `nestedProps` object.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * should be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  updateOptions,\r\n  setCliOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Sends a GET request to the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function get\r\n *\r\n * @param {string} url - The URL to get data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function get(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    // Decide on the protocol\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n\r\n          // Get the full result and resolve the request\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with `requestOptions`\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    // Decide on the protocol\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            // Get the full result and resolve the request\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (`http` or `https`).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { get } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkCache(highchartsOptions, serverProxyOptions) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n\r\n      // The initial cache update\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        // Check the Highcharts version\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        // Check the number of modules\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = _extractHcVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions.version, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHcVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHcVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the scripts of a new version.\r\n *\r\n * @async\r\n * @function updateHcVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHcVersion(newVersion) {\r\n  // Update to the new version\r\n  const options = updateOptions({\r\n    highcharts: {\r\n      version: newVersion\r\n    }\r\n  });\r\n\r\n  // Check if cache needs to be updated\r\n  await checkCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {number} version - The currently used Highcharts version.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which modules\r\n * have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(version, fetchedModules = {}) {\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = {\r\n    version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(cache.activeManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts content and information,\r\n * and used Highcharts version.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  try {\r\n    // Get Highcharts version for scripts\r\n    const hcVersion =\r\n      highchartsOptions.version === 'latest'\r\n        ? null\r\n        : `${highchartsOptions.version}`;\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    // Get the CDN url for scripts\r\n    const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n    // Prepare options for a request\r\n    const requestOptions = _configureRequest(serverProxyOptions);\r\n\r\n    // An object to record which scripts are fetched\r\n    const fetchedModules = {};\r\n\r\n    // Join all fetched scripts and save in the manifest's sources\r\n    cache.sources = (\r\n      await Promise.all([\r\n        // Highcharts core scripts fetch\r\n        ...highchartsOptions.coreScripts.map((cs) =>\r\n          _fetchScript(\r\n            hcVersion ? `${cdnUrl}/${hcVersion}/${cs}` : `${cdnUrl}/${cs}`,\r\n            requestOptions,\r\n            fetchedModules,\r\n            true\r\n          )\r\n        ),\r\n        // Highcharts module scripts fetch\r\n        ...highchartsOptions.moduleScripts.map((ms) =>\r\n          _fetchScript(\r\n            ms === 'map'\r\n              ? hcVersion\r\n                ? `${cdnUrl}/maps/${hcVersion}/modules/${ms}`\r\n                : `${cdnUrl}/maps/modules/${ms}`\r\n              : hcVersion\r\n                ? `${cdnUrl}/${hcVersion}/modules/${ms}`\r\n                : `${cdnUrl}/modules/${ms}`,\r\n            requestOptions,\r\n            fetchedModules\r\n          )\r\n        ),\r\n        // Highcharts indicator scripts fetch\r\n        ...highchartsOptions.indicatorScripts.map((is) =>\r\n          _fetchScript(\r\n            hcVersion\r\n              ? `${cdnUrl}/stock/${hcVersion}/indicators/${is}`\r\n              : `${cdnUrl}/stock/indicators/${is}`,\r\n            requestOptions,\r\n            fetchedModules\r\n          )\r\n        ),\r\n        // Custom scripts fetch\r\n        ...highchartsOptions.customScripts.map((cs) =>\r\n          _fetchScript(`${cs}`, requestOptions)\r\n        )\r\n      ])\r\n    ).join(';\\n');\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = _extractHcVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n\r\n    // Return the fetched modules\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional requests options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await get(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = _extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Configures a proxy agent for outgoing HTTP requests based on the provided\r\n * `server.proxy` options. If a valid `host` and `port` are specified, it tries\r\n * to create an `HttpsProxyAgent`. If the creation fails, an `ExportError`\r\n * is thrown. If no proxy is configured, an empty object is returned.\r\n *\r\n * @function _configureRequest\r\n *\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n *\r\n * @returns {Object} The request options, including the proxy agent if created,\r\n * or an empty object if no proxy configuration is provided.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the proxy agent creation\r\n * fails.\r\n */\r\nfunction _configureRequest(serverProxyOptions) {\r\n  // Get the `host` and `port` of the proxy\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a proxy agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      // Create the agent\r\n      const proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n\r\n      // Add the agent to the request's options\r\n      return {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      };\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // Return an empty object when no proxy agent is created\r\n  return {};\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function _extractHcVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nfunction _extractHcVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the `scriptPath` property.\r\n *\r\n * @function _extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nfunction _extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\nexport default {\r\n  checkCache,\r\n  getHcVersion,\r\n  updateHcVersion,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get all images from within the chart\r\n  const images = Array.from(\r\n    document.querySelectorAll('.highcharts-container image')\r\n  );\r\n\r\n  // Wait for all images for 2 seconds\r\n  await Promise.race([\r\n    Promise.all(\r\n      images.map((image) =>\r\n        image.complete && image.naturalHeight !== 0\r\n          ? Promise.resolve()\r\n          : new Promise((resolve) =>\r\n              image.addEventListener('load', resolve, { once: true })\r\n            )\r\n      )\r\n    ),\r\n    // Proceed further even if images did not load\r\n    new Promise((resolve) => setTimeout(resolve, 2000))\r\n  ]);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom JS and CSS resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that the browser and pages are correctly managed and can handle failures\r\n * during operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst pageTemplate = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * browser's launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n    const openBrowser = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to launch and get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await openBrowser();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      // Try to open a browser\r\n      await openBrowser();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    // No correct browser\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If `true`, navigates to `about:blank` and resets content\r\n * and scripts. If `false`, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to `true` when page\r\n * is correctly cleared and `false` when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use the content of the `resources`\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = file.startsWith('http') ? false : true;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    // The actual injection of collected scripts\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      const cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: getAbsolutePath(cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      // The actual injection of collected CSS\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(pageTemplate, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = await _getChartSize(page, isSVG, exportOptions.scale);\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Retrieves the real chart dimensions from a Puppeteer page. The function\r\n * behaves differently based on whether the export type is SVG or another\r\n * format.\r\n *\r\n * @async\r\n * @function _getChartSize\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {boolean} isSVG - Determines whether the chart being processed\r\n * is an SVG or another format.\r\n * @param {number} scale - The scale factor to be applied to the chart\r\n * dimensions.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * the actual height and width of the chart after scaling.\r\n */\r\nasync function _getChartSize(page, isSVG, scale) {\r\n  // Trigger appropriate function based on the `isSvg` flag to get chart size\r\n  return isSVG\r\n    ? await page.evaluate((scale) => {\r\n        const svgElement = document.querySelector(\r\n          '#chart-container svg:first-of-type'\r\n        );\r\n\r\n        // Get the values correctly scaled\r\n        const chartHeight = svgElement.height.baseVal.value * scale;\r\n        const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n        // In case of SVG the zoom must be set directly for body as scale\r\n        // eslint-disable-next-line no-undef\r\n        document.body.style.zoom = scale;\r\n\r\n        // Set the margin to 0px\r\n        // eslint-disable-next-line no-undef\r\n        document.body.style.margin = '0px';\r\n\r\n        return {\r\n          chartHeight,\r\n          chartWidth\r\n        };\r\n      }, parseFloat(scale))\r\n    : await page.evaluate(() => {\r\n        // eslint-disable-next-line no-undef\r\n        const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n        // No need for such scale manipulation in case of other types\r\n        // of exports. Reset the zoom for other exports than to SVGs\r\n        // eslint-disable-next-line no-undef\r\n        document.body.style.zoom = 1;\r\n\r\n        return {\r\n          chartHeight,\r\n          chartWidth\r\n        };\r\n      });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      _getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const exportResult = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (exportResult instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // Only `page.screenshot` will throw this, timeouts for PDF's are\r\n      // handled by the `page.pdf` function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (exportResult.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        exportResult.name === 'TimeoutError' ||\r\n        exportResult.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(exportResult);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(exportResult);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Update statistics\r\n    poolStats.timeSpent += exportCounter();\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportCounter()}ms.`);\r\n\r\n    // Otherwise return an object with the result and options\r\n    return {\r\n      result: exportResult,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    // Try to release the worker, if it exists\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or `null`\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function _getPoolInfo\r\n */\r\nfunction _getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`, `destroy`\r\n * functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a `TargetCloseError`, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input, allowing for the `foreignObject` elements\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions that prepare for the exporting\r\n * charts into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { isAllowedConfig, updateOptions, validateOption } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport { getAbsolutePath, getBase64, isObject, roundNumber } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n  try {\r\n    // Check if provided options are in an object\r\n    if (!isObject(imageOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = updateOptions(\r\n      {\r\n        export: imageOptions.export,\r\n        customLogic: imageOptions.customLogic\r\n      },\r\n      true\r\n    );\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.options = null;\r\n    options.export.instr = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.options = null;\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  // Get the `export` and `customLogic` options\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = _fixConstr(exportOptions.constr);\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = _fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = _fixOutfile(\r\n    exportOptions.type,\r\n    exportOptions.outfile\r\n  );\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the `customCode`, `callback`, and `resources` options\r\n  _handleCustomLogic(customLogicOptions);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(exportOptions, customLogicOptions);\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  _handleSize(exportOptions);\r\n\r\n  // Check if the image options object does not exceed the size limit\r\n  _checkDataSize({ export: exportOptions, customLogic: customLogicOptions });\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Handles adjusting the constructor name by transforming and normalizing\r\n * it based on common chart types.\r\n *\r\n * @function _fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be adjusted.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Handles fixing the outfile based on provided type.\r\n *\r\n * @function _fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile, or 'chart.png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type || 'png'}`;\r\n}\r\n\r\n/**\r\n * Handles fixing the export type based on MIME types and file extensions.\r\n *\r\n * @function _fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type, or 'png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Handle calculating the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _handleSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n */\r\nfunction _handleSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Find the `scale` value:\r\n  // - Cannot be lower than 0.1\r\n  // - Cannot be higher than 5.0\r\n  // - Must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Update `height`, `width`, and `scale` information in the `export` options\r\n  exportOptions.height = height;\r\n  exportOptions.width = width;\r\n  exportOptions.scale = scale;\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let param of ['height', 'width', 'scale']) {\r\n    if (typeof exportOptions[param] === 'string') {\r\n      exportOptions[param] = +exportOptions[param].replace(/px|%/gi, '');\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions) {\r\n  // In case of allowing code execution\r\n  if (customLogicOptions.allowCodeExecution) {\r\n    // Process the `resources` option\r\n    try {\r\n      // Try to handle resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n    } catch (error) {\r\n      log(2, '[chart] The `resources` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.resources = null;\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = _handleCustomCode(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = _handleCustomCode(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  let handledResources = resources;\r\n\r\n  // If no resources found, try to load the default resources\r\n  if (!handledResources) {\r\n    resources = 'resources.json';\r\n  }\r\n\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  // A flag that decides based to return resources or `null`\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (\r\n    allowFileResources &&\r\n    typeof resources === 'string' &&\r\n    resources.endsWith('.json')\r\n  ) {\r\n    handledResources = isAllowedConfig(\r\n      readFileSync(getAbsolutePath(resources), 'utf8'),\r\n      false,\r\n      allowCodeExecution\r\n    );\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Validate option\r\n  handledResources = validateOption('resources', handledResources);\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles custom code to execute it safely.\r\n *\r\n * @function _handleCustomCode\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nfunction _handleCustomCode(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? _handleCustomCode(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is `true`), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to `null`. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to `null`.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n */\r\nfunction _handleGlobalAndTheme(exportOptions, customLogicOptions) {\r\n  // Get the `allowFileResources` and `allowCodeExecution` flags\r\n  const { allowFileResources, allowCodeExecution } = customLogicOptions;\r\n\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the size of the data for the export process against a fixed limit\r\n * of 100MB.\r\n *\r\n * @function _checkDataSize\r\n *\r\n * @param {Object} imageOptions - The data object, which includes options from\r\n * the `export` and `customLogic` sections and will be sent to a Puppeteer page.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the size of the data for\r\n * the export process object exceeds the 100MB limit.\r\n */\r\nfunction _checkDataSize(imageOptions) {\r\n  // Set the fixed data limit (100MB) for the dev-tools protocol\r\n  const dataLimit = 100 * 1024 * 1024;\r\n\r\n  // Get the size of the data\r\n  const totalSize = Buffer.byteLength(JSON.stringify(imageOptions), 'utf-8');\r\n\r\n  // Log the size in MB\r\n  log(\r\n    3,\r\n    `[chart] The current total size of the data for the export process is around ${(\r\n      totalSize /\r\n      (1024 * 1024)\r\n    ).toFixed(2)}MB.`\r\n  );\r\n\r\n  // Check the size of data before passing to a page\r\n  if (totalSize >= dataLimit) {\r\n    throw new ExportError(\r\n      `[chart] The data for the export process exceeds 100MB limit.`\r\n    );\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed to avoid potential\r\n * memory leaks, unintended behavior or a process from being stopped.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled and the app exists\r\n    if (app && rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get and pre-validate the options and store them in the request\r\n    request.validatedOptions = {\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    };\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const options = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = options.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(options, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHcVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  // Add the UI endpoint only if required\r\n  if (getOptions().ui.enable) {\r\n    /**\r\n     * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n     */\r\n    app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n      try {\r\n        log(4, '[ui] Returning UI for the export.');\r\n\r\n        response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n          acceptRanges: false\r\n        });\r\n      } catch (error) {\r\n        return next(error);\r\n      }\r\n    });\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHcVersion, updateHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the new version from the params\r\n      const newVersion = request.params.newVersion;\r\n\r\n      // Update version\r\n      if (newVersion) {\r\n        try {\r\n          await updateHcVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHcVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middlewares setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      server: serverOptions\r\n    });\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions({\r\n    server: {\r\n      rateLimiting: rateLimitingOptions\r\n    }\r\n  });\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This core module initializes and manages the Highcharts Export\r\n * Server. The main `initExport` function handles logging, script caching,\r\n * resource pooling, browser startup, and ensures graceful process cleanup\r\n * on exit. Additionally, it provides API functions for using it as a Node.js\r\n * module, offering functionalities for processing options, configuring\r\n * and performing exports, and setting up server.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkCache } from './cache.js';\r\nimport {\r\n  batchExport,\r\n  singleExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} initOptions - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration.\r\n */\r\nexport async function initExport(initOptions) {\r\n  // Init, validate and update the options object\r\n  const options = updateOptions(initOptions);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check the current status of cache\r\n  await checkCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM',\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code: ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        level\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        toConsole\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        dest,\r\n        file,\r\n        toFile\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","getAbsolutePath","path","isAbsolute","normalize","resolve","getBase64","input","type","Buffer","from","toString","getNewDate","Date","split","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","shift","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","outfile","hint","choices","constr","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","allowFileResources","customCode","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","dotenv","config","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","includes","nullable","string","refine","params","errorMessage","values","stringArray","filterCallback","arraySchema","array","stringSchema","startsWith","slice","endsWith","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","forEach","index","substring","ExportError","Error","constructor","statusCode","super","setError","name","_initOptions","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","validateOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","propChain","entry","async","get","url","requestOptions","Promise","reject","_getProtocolModule","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","readFileSync","modules","moduleMap","m","numberOfModules","moduleName","_extractHcVersion","_saveConfigToManifest","getHcVersion","updateHcVersion","newVersion","writeFileSync","_configureRequest","all","cs","_fetchScript","ms","is","script","shouldThrowError","_extractModuleName","agent","HttpsProxyAgent","cacheSources","replace","scriptPath","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","images","querySelectorAll","race","image","complete","naturalHeight","addEventListener","once","setTimeout","defaultOptions","pageTemplate","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","openBrowser","launch","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","_getChartSize","x","y","_getClipRegion","viewportHeight","abs","ceil","chartHeight","viewportWidth","chartWidth","result","setViewport","deviceScaleFactor","parseFloat","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","svgElement","querySelector","baseVal","style","zoom","margin","outerHTML","clip","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","i","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","_getPoolInfo","acquireCounter","exportCounter","exportResult","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_fixConstr","_fixType","_fixOutfile","_handleCustomLogic","_handleGlobalAndTheme","_handleSize","_checkDataSize","fixedConstr","toLowerCase","mimeTypes","formats","outType","pop","find","t","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","_handleCustomCode","handledResources","allowedProps","correctResources","propName","isCallback","optionsName","totalSize","byteLength","toFixed","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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SACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbnF,KAAM,SAGVuF,OAAQ,CACN7D,MAAO,8BACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbnF,KAAM,SAGVwF,WAAY,CACV9D,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGVyF,UAAW,CACT/D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbnF,KAAM,SAGV0F,YAAa,CACXhE,MAAO,CAAC,aAAc,kBAAmB,iBACzCqD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBC,cAAe,CACblE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBE,iBAAkB,CAChBnE,MAAO,CAAC,kBACRqD,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBG,cAAe,CACbpE,MAAO,CACL,wEACA,kGAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbnF,KAAM,OACNoF,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACNtE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbnF,KAAM,SAGViG,MAAO,CACLvE,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbnF,KAAM,SAGVkG,QAAS,CACPxE,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbnF,KAAM,SAGVmG,IAAK,CACHzE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,aACTE,YAAa,mDACbC,cAAe,CACbnF,KAAM,SAGVoG,MAAO,CACL1E,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gEACFC,cAAe,CACbnF,KAAM,SAGVqG,QAAS,CACP3E,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,iBACTE,YACE,qFACFC,cAAe,CACbnF,KAAM,SAGVA,KAAM,CACJ0B,MAAO,MACPqD,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,oDACbC,cAAe,CACbnF,KAAM,SACNsG,KAAM,eACNC,QAAS,CAAC,MAAO,OAAQ,MAAO,SAGpCC,OAAQ,CACN9E,MAAO,QACPqD,MAAO,CAAC,UACRC,QAAS,gBACTE,YACE,uEACFC,cAAe,CACbnF,KAAM,SACNsG,KAAM,iBACNC,QAAS,CAAC,QAAS,aAAc,WAAY,gBAGjDE,IAAK,CACH/E,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,aACTE,YACE,oFACFC,cAAe,CACbnF,KAAM,WAGV0G,WAAY,CACVhF,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,qBACTE,YACE,0EACFC,cAAe,CACbnF,KAAM,WAGV2G,OAAQ,CACNjF,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YAAa,yDACbC,cAAe,CACbnF,KAAM,WAGV4G,MAAO,CACLlF,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YAAa,wDACbC,cAAe,CACbnF,KAAM,WAGV6G,MAAO,CACLnF,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,eACTE,YACE,gFACFC,cAAe,CACbnF,KAAM,WAGV8G,cAAe,CACbpF,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGV+G,aAAc,CACZrF,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,iDACbC,cAAe,CACbnF,KAAM,WAGVgH,aAAc,CACZtF,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YACE,yEACFC,cAAe,CACbnF,KAAM,SACNiH,IAAK,GACLC,IAAK,IAGTC,cAAe,CACbzF,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,wBACTE,YACE,mFACFC,cAAe,CACbnF,KAAM,SAGVoH,aAAc,CACZ1F,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,uBACTE,YACE,kFACFC,cAAe,CACbnF,KAAM,SAGVqH,qBAAsB,CACpB3F,MAAO,KACPqD,MAAO,CAAC,UACRC,QAAS,+BACTE,YAAa,6CACbC,cAAe,CACbnF,KAAM,YAIZsH,YAAa,CACXC,mBAAoB,CAClB7F,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oCACTE,YACE,mEACFC,cAAe,CACbnF,KAAM,WAGVwH,mBAAoB,CAClB9F,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oCACTE,YACE,kFACFC,cAAe,CACbnF,KAAM,WAGVyH,WAAY,CACV/F,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,2BACTE,YACE,uHACFC,cAAe,CACbnF,KAAM,SAGV0H,SAAU,CACRhG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,wBACTE,YACE,kFACFC,cAAe,CACbnF,KAAM,SAGV2H,UAAW,CACTjG,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,yBACTE,YACE,sGACFC,cAAe,CACbnF,KAAM,SAGV4H,WAAY,CACVlG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,2BACT6C,WAAY,WACZ3C,YAAa,+CACbC,cAAe,CACbnF,KAAM,SAGV8H,aAAc,CACZpG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,6BACTE,YACE,+DACFC,cAAe,CACbnF,KAAM,UAIZ+H,OAAQ,CACNC,OAAQ,CACNtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,gBACTC,QAAS,eACTC,YAAa,8BACbC,cAAe,CACbnF,KAAM,WAGViI,KAAM,CACJvG,MAAO,UACPqD,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,yBACbC,cAAe,CACbnF,KAAM,SAGVkI,KAAM,CACJxG,MAAO,KACPqD,MAAO,CAAC,UACRC,QAAS,cACTE,YAAa,6BACbC,cAAe,CACbnF,KAAM,WAGVmI,YAAa,CACXzG,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,sBACTE,YAAa,kCACbC,cAAe,CACbnF,KAAM,WAGVoI,aAAc,CACZ1G,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,sBACTC,QAAS,qBACTC,YACE,0EACFC,cAAe,CACbnF,KAAM,WAGVqI,MAAO,CACLJ,KAAM,CACJvG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,oBACTC,QAAS,YACTC,YAAa,0CACbC,cAAe,CACbnF,KAAM,SAGVkI,KAAM,CACJxG,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,oBACTC,QAAS,YACTC,YAAa,0CACbC,cAAe,CACbnF,KAAM,WAGVsI,QAAS,CACP5G,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTC,QAAS,eACTC,YACE,8DACFC,cAAe,CACbnF,KAAM,YAIZuI,aAAc,CACZP,OAAQ,CACNtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,8BACTC,QAAS,qBACTC,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGVwI,YAAa,CACX9G,MAAO,GACPqD,MAAO,CAAC,UACRC,QAAS,oCACT6C,WAAY,YACZ3C,YAAa,gDACbC,cAAe,CACbnF,KAAM,WAGVyI,OAAQ,CACN/G,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,8BACTE,YAAa,2CACbC,cAAe,CACbnF,KAAM,WAGV0I,MAAO,CACLhH,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,6BACTE,YACE,uEACFC,cAAe,CACbnF,KAAM,WAGV2I,WAAY,CACVjH,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,mCACTE,YAAa,sDACbC,cAAe,CACbnF,KAAM,WAGV4I,QAAS,CACPlH,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gCACTE,YAAa,wDACbC,cAAe,CACbnF,KAAM,SAGV6I,UAAW,CACTnH,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,kCACTE,YAAa,wDACbC,cAAe,CACbnF,KAAM,UAIZ8I,IAAK,CACHd,OAAQ,CACNtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oBACTC,QAAS,YACTC,YAAa,mCACbC,cAAe,CACbnF,KAAM,WAGV+I,MAAO,CACLrH,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,mBACTC,QAAS,WACT4C,WAAY,UACZ3C,YAAa,gDACbC,cAAe,CACbnF,KAAM,WAGVkI,KAAM,CACJxG,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,kBACTC,QAAS,UACTC,YAAa,0BACbC,cAAe,CACbnF,KAAM,WAGVgJ,SAAU,CACRtH,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,uBACTC,QAAS,cACT4C,WAAY,UACZ3C,YAAa,uCACbC,cAAe,CACbnF,KAAM,WAKdiJ,KAAM,CACJC,WAAY,CACVxH,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,mBACTE,YAAa,sDACbC,cAAe,CACbnF,KAAM,WAGVmJ,WAAY,CACVzH,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,mBACT6C,WAAY,UACZ3C,YAAa,0CACbC,cAAe,CACbnF,KAAM,WAGVoJ,UAAW,CACT1H,MAAO,GACPqD,MAAO,CAAC,UACRC,QAAS,kBACTE,YAAa,wDACbC,cAAe,CACbnF,KAAM,WAGVqJ,eAAgB,CACd3H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,mDACbC,cAAe,CACbnF,KAAM,WAGVsJ,cAAe,CACb5H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,sBACTE,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGVuJ,eAAgB,CACd7H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,oDACbC,cAAe,CACbnF,KAAM,WAGVwJ,YAAa,CACX9H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,oBACTE,YAAa,wDACbC,cAAe,CACbnF,KAAM,WAGVyJ,oBAAqB,CACnB/H,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,6BACTE,YACE,wEACFC,cAAe,CACbnF,KAAM,WAGV0J,eAAgB,CACdhI,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YACE,+DACFC,cAAe,CACbnF,KAAM,WAGVoI,aAAc,CACZ1G,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,oBACTC,QAAS,mBACTC,YAAa,6CACbC,cAAe,CACbnF,KAAM,YAIZiC,QAAS,CACPY,MAAO,CACLnB,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,gBACTC,QAAS,WACTC,YAAa,0BACbC,cAAe,CACbnF,KAAM,SACN+B,MAAO,EACPkF,IAAK,EACLC,IAAK,IAGT7C,KAAM,CACJ3C,MAAO,+BACPqD,MAAO,CAAC,UACRC,QAAS,eACTC,QAAS,UACTC,YACE,8DACFC,cAAe,CACbnF,KAAM,SAGVoE,KAAM,CACJ1C,MAAO,MACPqD,MAAO,CAAC,UACRC,QAAS,eACTC,QAAS,UACTC,YAAa,0DACbC,cAAe,CACbnF,KAAM,SAGVkC,UAAW,CACTR,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,qBACTC,QAAS,eACTC,YAAa,sCACbC,cAAe,CACbnF,KAAM,WAGVmC,OAAQ,CACNT,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,kBACTC,QAAS,YACTC,YAAa,wCACbC,cAAe,CACbnF,KAAM,YAIZ2J,GAAI,CACF3B,OAAQ,CACNtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,YACTC,QAAS,WACTC,YAAa,mDACbC,cAAe,CACbnF,KAAM,WAGV4J,MAAO,CACLlI,MAAO,IACPqD,MAAO,CAAC,UACRC,QAAS,WACTC,QAAS,UACTC,YAAa,gCACbC,cAAe,CACbnF,KAAM,UAIZ6J,MAAO,CACLC,QAAS,CACPpI,MAAO,aACPqD,MAAO,CAAC,UACRC,QAAS,iBACTE,YAAa,+BACbC,cAAe,CACbnF,KAAM,SAGV+J,qBAAsB,CACpBrI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,gCACTE,YAAa,iDACbC,cAAe,CACbnF,KAAM,WAGVgK,OAAQ,CACNtI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,gBACTE,YAAa,+CACbC,cAAe,CACbnF,KAAM,WAGViK,cAAe,CACbvI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,wBACTE,YAAa,oDACbC,cAAe,CACbnF,KAAM,WAGVkK,iBAAkB,CAChBxI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,2BACTE,YAAa,yDACbC,cAAe,CACbnF,KAAM,WAGVmK,WAAY,CACVzI,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,mBACTE,YAAa,uDACbC,cAAe,CACbnF,KAAM,YAIZoK,MAAO,CACLpC,OAAQ,CACNtG,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,eACTC,QAAS,cACTC,YAAa,4DACbC,cAAe,CACbnF,KAAM,WAGVqK,SAAU,CACR3I,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,iBACTE,YACE,6EACFC,cAAe,CACbnF,KAAM,WAGVsK,SAAU,CACR5I,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,iBACTE,YAAa,+CACbC,cAAe,CACbnF,KAAM,WAGVuK,gBAAiB,CACf7I,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,0BACTE,YACE,qEACFC,cAAe,CACbnF,KAAM,WAGVwK,OAAQ,CACN9I,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,eACTE,YACE,kFACFC,cAAe,CACbnF,KAAM,WAGVyK,OAAQ,CACN/I,MAAO,EACPqD,MAAO,CAAC,UACRC,QAAS,gBACTE,YAAa,4DACbC,cAAe,CACbnF,KAAM,WAGV0K,cAAe,CACbhJ,MAAO,KACPqD,MAAO,CAAC,UACRC,QAAS,uBACTE,YAAa,0BACbC,cAAe,CACbnF,KAAM,aCl8Bd2K,OAAOC,SAGP,MAAMlF,YAAEA,YAAWE,cAAEA,cAAaC,iBAAEA,kBAClChB,cAAcQ,WAGhBwF,IAAAA,EAAEC,YAAYC,iBAWd,MAAMC,EAAI,CAwBRC,QAAQC,GACCA,EACHL,IAAAA,EAAEI,UACFJ,IAACA,EACEM,MAAM,CACLN,IAACA,EACEO,KAAK,CAAC,OAAQ,IAAK,QAAS,IAAK,YAAa,OAAQ,KACtDC,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAEhC,KADU,SAAVA,GAA8B,MAAVA,IAG5BmJ,IAAAA,EAAEI,YAEHM,WAuBTC,OAAON,GACEA,EACHL,IAACA,EACEW,SACAjL,OACAkL,QACE/J,IAAW,CAAC,QAAS,YAAa,OAAQ,IAAI4J,SAAS5J,IACxD,CACEgK,OAAQ,CACNC,aAAc,2CAItBd,IAACA,EACEW,SACAjL,OACA8K,WAAW3J,GACT,CAAC,QAAS,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAEvD6J,WA0BTH,KAAI,CAACQ,EAAQV,IACJA,EACHL,IAAAA,EAAEO,KAAK,IAAIQ,IACXf,IAACA,EACEO,KAAK,IAAIQ,EAAQ,YAAa,OAAQ,KACtCP,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAE9C6J,WA4BT,WAAAM,CAAYC,EAAgB1G,EAAW8F,GACrC,MAAMa,EAAclB,IAAAA,EAAEW,SAASjL,OAAOyL,QAChCC,EAAepB,IAACA,EACnBW,SACAjL,OACA8K,WAAW3J,IACNA,EAAMwK,WAAW,OACnBxK,EAAQA,EAAMyK,MAAM,IAElBzK,EAAM0K,SAAS,OACjB1K,EAAQA,EAAMyK,MAAM,GAAK,IAEpBzK,EAAMpB,MAAM8E,MAGjBiH,EAAqB3K,GACzBA,EAAMqC,KAAKrC,GAAUA,EAAMnB,SAAQ+L,OAAOR,GAE5C,OAAOZ,EACHa,EAAYV,UAAUgB,GACtBxB,IAACA,EACEM,MAAM,CAACc,EAAcF,IACrBV,UAAUgB,GACVhB,WAAW3J,GAAWA,EAAMZ,OAASY,EAAQ,OAC7C6J,UACR,EAwBDgB,YAAYrB,GACHA,EACHL,MAAE2B,SAASC,WACX5B,IAACA,EACEM,MAAM,CACLN,IAACA,EACEW,SACAjL,OACAkL,QACE/J,IACGgL,MAAMlL,OAAOE,KAAWF,OAAOE,GAAS,GAC1C,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aAAc,4CAInBN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAEhC,KADAF,OAAOE,KAGfmJ,MAAE2B,SAASC,aAEZlB,WA0BToB,eAAezB,GACNA,EACHL,MAAE2B,SAASI,cACX/B,IAACA,EACEM,MAAM,CACLN,IAACA,EACEW,SACAjL,OACAkL,QACE/J,IACGgL,MAAMlL,OAAOE,KAAWF,OAAOE,IAAU,GAC3C,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aAAc,gDAInBN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAEhC,KADAF,OAAOE,KAGfmJ,MAAE2B,SAASI,gBAEZrB,WA8BTW,WAAU,CAACW,EAAU3B,IACZA,EACHL,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GAAUmL,EAAS7L,MAAM8B,GAAWpB,EAAMwK,WAAWpJ,MACtD,CACE4I,OAAQ,CACNC,aAAc,+CAA+CkB,EAAS5I,KAAK,WAInF4G,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACCmL,EAAS7L,MAAM8B,GAAWpB,EAAMwK,WAAWpJ,MAC3C,CAAC,YAAa,OAAQ,IAAIwI,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aAAc,+CAA+CkB,EAAS5I,KAAK,WAIhFoH,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAE9C6J,WAgBTuB,YAAW,IACFjC,IAACA,EACLM,MAAM,CACLN,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACEA,EAAMwK,WAAW,MAAQxK,EAAM0K,SAAS,MACzC,CAAC,YAAa,OAAQ,IAAId,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aACE,uEAIPN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAEjDmJ,IAAAA,EAAEkC,OAAO,IAAIC,gBAEdzB,WAiBL0B,kBAAiB,IACRpC,IAACA,EACLM,MAAM,CACLN,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACEA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACpC1K,EAAMwK,WAAW,MAAQxK,EAAM0K,SAAS,MACzC,CAAC,YAAa,OAAQ,IAAId,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aACE,4FAIPN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAEjDmJ,IAAAA,EAAEkC,OAAO,IAAIC,gBAEdzB,YAaM2B,WAAa,CAexBxK,KAAKwI,GACIF,EAAEa,aACNnK,IAAW,CAAC,QAAS,YAAa,OAAQ,IAAI4J,SAAS5J,IACxD,IACAwJ,GA2BJ5F,QAAQ4F,GACCA,EACHL,IAACA,EACEW,SACAjL,OACAkL,QAAQ/J,GAAU,qCAAqCR,KAAKQ,IAAQ,CACnEgK,OAAQ,CACNC,aACE,0EAGRd,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACC,qCAAqCR,KAAKQ,IAC1C,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aACE,0EAIPN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAE9C6J,WAiBThG,OAAO2F,GACEF,EAAEkB,WAAW,CAAC,UAAW,YAAahB,GAiB/C1F,WAAW0F,GACFF,EAAEC,QAAQC,GAiBnBzF,UAAUyF,GACDF,EAAEQ,OAAON,GAiBlBiC,WAAWjC,GACFF,EAAEQ,OAAON,GAiBlBxF,YAAYwF,GACHF,EAAEa,aACNnK,GAAUgE,YAAYhE,MAAM4J,SAAS5J,IACtC,IACAwJ,GAkBJtF,cAAcsF,GACLF,EAAEa,aACNnK,GAAUkE,cAAclE,MAAM4J,SAAS5J,IACxC,IACAwJ,GAkBJrF,iBAAiBqF,GACRF,EAAEa,aACNnK,GAAUmE,iBAAiBnE,MAAM4J,SAAS5J,IAC3C,IACAwJ,GAkBJpF,cAAcoF,GACLF,EAAEa,aACNnK,GAAUA,EAAMwK,WAAW,aAAexK,EAAMwK,WAAW,YAC5D,IACAhB,GA2BJlF,OAAOkF,GACEA,EACHL,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACEA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACpC1K,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,SACvC,CACEV,OAAQ,CACNC,aACE,6DAIPJ,WACHV,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACEA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACpC1K,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,SACrC,CAAC,YAAa,OAAQ,IAAId,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aACE,6DAIPN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAE9C6J,WAaTtF,MAAK,IACI+E,EAAE8B,cAaX5G,QAAO,IACE8E,EAAE8B,cAiBX3G,IAAG,IACM0E,IAACA,EACLW,SACAjL,OACAkL,QACE/J,GACCA,EAAM0L,QAAQ,SAAW,GACzB1L,EAAM0L,QAAQ,UAAY,GAC1B,CAAC,QAAS,YAAa,OAAQ,IAAI9B,SAAS5J,IAC9C,CACEgK,OAAQ,CACNC,aACE,gEAIPN,WAAW3J,GACT,CAAC,QAAS,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAEvD6J,WA0BLlF,QAAQ6E,GACCA,EACHL,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACEA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACpC1K,EAAMZ,QAAU,IACdY,EAAM0K,SAAS,SACd1K,EAAM0K,SAAS,SACf1K,EAAM0K,SAAS,SACf1K,EAAM0K,SAAS,UACrB,CACEV,OAAQ,CACNC,aACE,gFAIPJ,WACHV,IAACA,EACEW,SACAjL,OACAkL,QACE/J,GACEA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACpC1K,EAAMZ,QAAU,IACdY,EAAM0K,SAAS,SACd1K,EAAM0K,SAAS,SACf1K,EAAM0K,SAAS,SACf1K,EAAM0K,SAAS,UACnB,CAAC,YAAa,OAAQ,IAAId,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aACE,gFAIPN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAE9C6J,WAiBTvL,KAAKkL,GACIF,EAAEI,KAAK,CAAC,OAAQ,MAAO,MAAO,MAAO,OAAQF,GAiBtD1E,OAAO0E,GACEF,EAAEI,KACP,CAAC,QAAS,aAAc,WAAY,cACpCF,GAiBJzE,IAAIyE,GACKF,EAAEC,QAAQC,GAiBnBxE,WAAWwE,GACFF,EAAEC,QAAQC,GAiBnBpE,cAAcoE,GACLF,EAAEuB,YAAYrB,GAiBvBnE,aAAamE,GACJF,EAAEuB,YAAYrB,GAwBvBlE,aAAakE,GACJA,EACHL,IAACA,EAAC2B,SAASa,IAAI,IAAKC,IAAI,GACxBzC,IAACA,EACEM,MAAM,CACLN,IAACA,EACEW,SACAjL,OACAkL,QACE/J,IACGgL,MAAMlL,OAAOE,MACH,IAAVA,IACCA,EAAMwK,WAAW,MAClB1K,OAAOE,IAAU,IACjBF,OAAOE,IAAU,GACnB,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aAAc,kDAInBN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAEhC,KADAF,OAAOE,KAGfmJ,IAACA,EAAC2B,SAASa,IAAI,IAAKC,IAAI,KAEzB/B,WAkBT,MAAA5E,CAAOuE,GACL,OAAOqC,KAAKzG,cAAcoE,GAAaK,UACxC,EAiBD,KAAA3E,CAAMsE,GACJ,OAAOqC,KAAKxG,aAAamE,GAAaK,UACvC,EAiBD,KAAA1E,CAAMqE,GACJ,OAAOqC,KAAKvG,aAAakE,GAAaK,UACvC,EAaDpE,cAAa,IACJ6D,EAAEiC,oBAcX7F,aAAY,IACH4D,EAAEiC,oBAiBX7G,MAAM8E,GACGF,EAAEQ,OAAON,GAkBlB7D,qBAAqB6D,GACZF,EAAE2B,eAAezB,GAiB1B3D,mBAAmB2D,GACVF,EAAEC,QAAQC,GAiBnB1D,mBAAmB0D,GACVF,EAAEC,QAAQC,GAiBnBzD,WAAWyD,GACFF,EAAEQ,OAAON,GAiBlBxD,SAASwD,GACAF,EAAEQ,OAAON,GA4BlB,SAAAvD,CAAUuD,GACR,MAAMsC,EAAe3C,IAACA,EACnBkC,OAAO,CACNU,GAAIzC,EAAEQ,QAAO,GACbkC,IAAK1C,EAAEQ,QAAO,GACdmC,MAAO3C,EACJa,aACEnK,IAAW,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,IAC/C,KACA,GAED6J,aAEJqC,UAEGC,EAAgBhD,IAACA,EACpBW,SACAjL,OACAkL,QACE/J,GACEA,EAAMwK,WAAW,MAAQxK,EAAM0K,SAAS,MACxC1K,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACvC,CACEV,OAAQ,CACNC,aACE,sEAKJmC,EAAgBjD,IAACA,EACpBW,SACAjL,OACAkL,QACE/J,GACEA,EAAMwK,WAAW,MAAQxK,EAAM0K,SAAS,MACxC1K,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACrC,CAAC,YAAa,OAAQ,IAAId,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aAAc,qDAInBN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAAiB,KAARA,IAGjD,OAAOwJ,EACHL,IAACA,EAACM,MAAM,CAACqC,EAAcK,IAAgBtC,WACvCV,IAACA,EAACM,MAAM,CAACqC,EAAcM,IAAgBvC,UAC5C,EAiBD3D,WAAWsD,GACFF,EACJQ,OAAON,GACPO,QACE/J,GACW,OAAVA,GAAmBA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,UACzD,CACEV,OAAQ,CACNC,aAAc,qDAoBxB,YAAA7D,CAAaoD,GACX,OAAOqC,KAAK3F,WAAWsD,EACxB,EAgBD6C,aAAa7C,GACJF,EAAEC,QAAQC,GAiBnBjD,KAAKiD,GACIF,EAAEQ,OAAON,GAkBlBhD,KAAKgD,GACIF,EAAE2B,eAAezB,GAiB1B/C,YAAY+C,GACHF,EAAEuB,YAAYrB,GAiBvB8C,mBAAmB9C,GACVF,EAAEC,QAAQC,GAiBnB+C,UAAU/C,GACDF,EAAEQ,OAAON,GAkBlBgD,UAAUhD,GACDF,EAAE2B,eAAezB,GAAaK,WAkBvC4C,aAAajD,GACJF,EAAE2B,eAAezB,GAiB1BkD,mBAAmBlD,GACVF,EAAEC,QAAQC,GAkBnB1C,YAAY0C,GACHF,EAAE2B,eAAezB,GAkB1BzC,OAAOyC,GACEF,EAAE2B,eAAezB,GAkB1BxC,MAAMwC,GACGF,EAAE2B,eAAezB,GAiB1BvC,WAAWuC,GACFF,EAAEC,QAAQC,GAiBnBtC,QAAQsC,GACCF,EAAEQ,OAAON,GAiBlBrC,UAAUqC,GACDF,EAAEQ,OAAON,GAiBlBmD,UAAUnD,GACDF,EAAEC,QAAQC,GAiBnBoD,SAASpD,GACAF,EAAEC,QAAQC,GAkBnBqD,QAAQrD,GACCF,EAAE2B,eAAezB,GAiB1BsD,YAAYtD,GACHF,EAAEQ,OAAON,GAiBlBhC,WAAWgC,GACFF,EAAEuB,YAAYrB,GAiBvB/B,WAAW+B,GACFF,EAAEuB,YAAYrB,GAiBvB9B,UAAU8B,GACDF,EAAEuB,YAAYrB,GAkBvB7B,eAAe6B,GACNF,EAAE2B,eAAezB,GAkB1B5B,cAAc4B,GACLF,EAAE2B,eAAezB,GAkB1B3B,eAAe2B,GACNF,EAAE2B,eAAezB,GAkB1B1B,YAAY0B,GACHF,EAAE2B,eAAezB,GAkB1BzB,oBAAoByB,GACXF,EAAE2B,eAAezB,GAkB1BxB,eAAewB,GACNF,EAAE2B,eAAezB,GAiB1BuD,iBAAiBvD,GACRF,EAAEC,QAAQC,GAkBnBwD,kBAAkBxD,GACTF,EAAE2B,eAAezB,GAwB1ByD,SAASzD,GACAA,EACHL,MAAE2B,SAASoC,MAAMvB,IAAI,GAAGC,IAAI,GAC5BzC,IAACA,EACEM,MAAM,CACLN,IAACA,EACEW,SACAjL,OACAkL,QACE/J,IACGgL,MAAMlL,OAAOE,MACH,IAAVA,IACCA,EAAMwK,WAAW,MAClB1K,OAAOiD,UAAUjD,OAAOE,KACxBF,OAAOE,IAAU,GACjBF,OAAOE,IAAU,GACnB,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,IACrC,CACEgK,OAAQ,CACNC,aAAc,8CAInBN,WAAW3J,GACT,CAAC,YAAa,OAAQ,IAAI4J,SAAS5J,GAEhC,KADAF,OAAOE,KAGfmJ,MAAE2B,SAASoC,MAAMvB,IAAI,GAAGC,IAAI,KAE7B/B,WAkBTsD,QAAQ3D,GACCF,EACJQ,OAAON,GACPO,QACE/J,GACW,OAAVA,GAAmBA,EAAMZ,QAAU,GAAKY,EAAM0K,SAAS,SACzD,CACEV,OAAQ,CACNC,aAAc,oDAoBxBmD,QAAQ5D,GACCF,EAAEQ,OAAON,GAiBlB6D,aAAa7D,GACJF,EAAEC,QAAQC,GAiBnB8D,UAAU9D,GACDF,EAAEC,QAAQC,GAiBnB+D,SAAS/D,GACAF,EAAEC,QAAQC,GAiBnBgE,QAAQhE,GACCF,EAAEkB,WAAW,CAAC,KAAMhB,GAiB7BpB,QAAQoB,GACCF,EAAEI,KAAK,CAAC,cAAe,aAAc,QAASF,GAiBvDnB,qBAAqBmB,GACZF,EAAEC,QAAQC,GAiBnBlB,OAAOkB,GACEF,EAAEC,QAAQC,GAiBnBjB,cAAciB,GACLF,EAAEC,QAAQC,GAiBnBhB,iBAAiBgB,GACRF,EAAEC,QAAQC,GAiBnBf,WAAWe,GACFF,EAAEC,QAAQC,GAiBnBiE,YAAYjE,GACHF,EAAEC,QAAQC,GAiBnBb,SAASa,GACAF,EAAEC,QAAQC,GAiBnBZ,SAASY,GACAF,EAAEC,QAAQC,GAiBnBX,gBAAgBW,GACPF,EAAEC,QAAQC,GAiBnBV,OAAOU,GACEF,EAAEC,QAAQC,GAkBnBT,OAAOS,GACEF,EAAE2B,eAAezB,GAkB1BR,cAAcQ,GACLF,EAAE2B,eAAezB,GAkB1BkE,UAAS,IACAvE,IAACA,EACLW,SACA6D,KAAK,CAAE7L,QAAS,yCAChB+H,YAKD+D,gBAAmBpE,GACvBL,IAACA,EACEkC,OAAO,CACNrK,KAAMwK,WAAWxK,KAAKwI,KAEvB0C,UAGC2B,iBAAoBrE,GACxBL,IAACA,EACEkC,OAAO,CACNzH,QAAS4H,WAAW5H,QAAQ4F,GAC5B3F,OAAQ2H,WAAW3H,OAAO2F,GAC1B1F,WAAY0H,WAAW1H,WAAW0F,GAClCzF,UAAWyH,WAAWzH,UAAUyF,GAChCxF,YAAawH,WAAWxH,YAAYwF,GACpCtF,cAAesH,WAAWtH,cAAcsF,GACxCrF,iBAAkBqH,WAAWrH,iBAAiBqF,GAC9CpF,cAAeoH,WAAWpH,cAAcoF,KAEzC0C,UAGC4B,aAAgBtE,GACpBL,IAACA,EACEkC,OAAO,CACN/G,OAAQkH,WAAWlH,OAAOkF,GAC1BjF,MAAOiH,WAAWjH,QAClBC,QAASgH,WAAWhH,UACpBC,IAAK+G,WAAW/G,MAChBE,QAAS6G,WAAW7G,QAAQ6E,GAC5BlL,KAAMkN,WAAWlN,KAAKkL,GACtB1E,OAAQ0G,WAAW1G,OAAO0E,GAC1BzE,IAAKyG,WAAWzG,IAAIyE,GACpBxE,WAAYwG,WAAWxG,WAAWwE,GAClCpE,cAAeoG,WAAWpG,cAAcoE,GACxCnE,aAAcmG,WAAWnG,aAAamE,GACtClE,aAAckG,WAAWlG,aAAakE,GACtCvE,OAAQuG,WAAWvG,OAAOuE,GAC1BtE,MAAOsG,WAAWtG,MAAMsE,GACxBrE,MAAOqG,WAAWrG,MAAMqE,GACxB/D,cAAe+F,WAAW/F,gBAC1BC,aAAc8F,WAAW9F,eACzBhB,MAAO8G,WAAW9G,OAAM,GACxBiB,qBAAsB6F,WAAW7F,qBAAqB6D,KAEvD0C,UAGC6B,kBAAqBvE,GACzBL,IAACA,EACEkC,OAAO,CACNxF,mBAAoB2F,WAAW3F,mBAAmB2D,GAClD1D,mBAAoB0F,WAAW1F,mBAAmB0D,GAClDzD,WAAYyF,WAAWzF,YAAW,GAClCC,SAAUwF,WAAWxF,UAAS,GAC9BC,UAAWuF,WAAWvF,UAAUuD,GAChCtD,WAAYsF,WAAWtF,YAAW,GAClCE,aAAcoF,WAAWpF,cAAa,KAEvC8F,UAGC8B,YAAexE,GACnBL,IAACA,EACEkC,OAAO,CACN9E,KAAMiF,WAAWe,WAAU,GAC3B/F,KAAMgF,WAAWgB,UAAUhD,GAC3B5C,QAAS4E,WAAWiB,aAAajD,KAElC0C,UAGC+B,mBAAsBzE,GAC1BL,IAACA,EACEkC,OAAO,CACN/E,OAAQkF,WAAWkB,mBAAmBlD,GACtC1C,YAAa0E,WAAW1E,YAAY0C,GACpCzC,OAAQyE,WAAWzE,OAAOyC,GAC1BxC,MAAOwE,WAAWxE,MAAMwC,GACxBvC,WAAYuE,WAAWvE,WAAWuC,GAClCtC,QAASsE,WAAWtE,SAAQ,GAC5BC,UAAWqE,WAAWrE,WAAU,KAEjC+E,UAGCgC,UAAa1E,GACjBL,IAACA,EACEkC,OAAO,CACN/E,OAAQkF,WAAWmB,UAAUnD,GAC7BnC,MAAOmE,WAAWoB,SAASpD,GAC3BhD,KAAMgF,WAAWqB,QAAQrD,GACzBlC,SAAUkE,WAAWsB,aAAY,KAElCZ,UAGCiC,aAAgB3E,GACpBL,IAAAA,EAAEkC,OAAO,CACP/E,OAAQkF,WAAWa,aAAa7C,GAAa4E,WAC7C7H,KAAMiF,WAAWjF,KAAKiD,GAAa4E,WACnC5H,KAAMgF,WAAWhF,KAAKgD,GAAa4E,WACnC3H,YAAa+E,WAAW/E,YAAY+C,GAAa4E,WACjD1H,aAAc8E,WAAWc,mBAAmB9C,GAAa4E,WACzDzH,MAAOqH,YAAYxE,GAAa4E,WAChCvH,aAAcoH,mBAAmBzE,GAAa4E,WAC9ChH,IAAK8G,UAAU1E,GAAa4E,aAI1BC,WAAc7E,GAClBL,IAACA,EACEkC,OAAO,CACN7D,WAAYgE,WAAWhE,WAAWgC,GAClC/B,WAAY+D,WAAW/D,WAAW+B,GAClC9B,UAAW8D,WAAW9D,UAAU8B,GAChC7B,eAAgB6D,WAAW7D,eAAe6B,GAC1C5B,cAAe4D,WAAW5D,cAAc4B,GACxC3B,eAAgB2D,WAAW3D,eAAe2B,GAC1C1B,YAAa0D,WAAW1D,YAAY0B,GACpCzB,oBAAqByD,WAAWzD,oBAAoByB,GACpDxB,eAAgBwD,WAAWxD,eAAewB,GAC1C9C,aAAc8E,WAAWuB,iBAAiBvD,KAE3C0C,UAGCoC,cAAiB9E,GACrBL,IAACA,EACEkC,OAAO,CACNlK,MAAOqK,WAAWyB,SAASzD,GAC3B7G,KAAM6I,WAAW2B,QAAQ3D,GACzB9G,KAAM8I,WAAW4B,QAAQ5D,GACzBhJ,UAAWgL,WAAW6B,aAAa7D,GACnC/I,OAAQ+K,WAAW8B,UAAU9D,KAE9B0C,UAGCqC,SAAY/E,GAChBL,IAACA,EACEkC,OAAO,CACN/E,OAAQkF,WAAW+B,SAAS/D,GAC5BtB,MAAOsD,WAAWgC,QAAQhE,KAE3B0C,UAGCsC,YAAehF,GACnBL,IAACA,EACEkC,OAAO,CACNjD,QAASoD,WAAWpD,QAAQoB,GAC5BnB,qBAAsBmD,WAAWnD,qBAAqBmB,GACtDlB,OAAQkD,WAAWlD,OAAOkB,GAC1BjB,cAAeiD,WAAWjD,cAAciB,GACxChB,iBAAkBgD,WAAWhD,iBAAiBgB,GAC9Cf,WAAY+C,WAAW/C,WAAWe,KAEnC0C,UAGCuC,YAAejF,GACnBL,IAACA,EACEkC,OAAO,CACN/E,OAAQkF,WAAWiC,YAAYjE,GAC/Bb,SAAU6C,WAAW7C,SAASa,GAC9BZ,SAAU4C,WAAW5C,SAASY,GAC9BX,gBAAiB2C,WAAW3C,gBAAgBW,GAC5CV,OAAQ0C,WAAW1C,OAAOU,GAC1BT,OAAQyC,WAAWzC,OAAOS,GAC1BR,cAAewC,WAAWxC,cAAcQ,KAEzC0C,UAGQwC,mBAAqBvF,IAACA,EAACkC,OAAO,CACzCqC,UAAWlC,WAAWkC,YACtBtK,UAAWwK,iBAAgB,GAC3BjK,WAAYkK,kBAAiB,GAC7BxJ,OAAQyJ,cAAa,GACrBlI,YAAamI,mBAAkB,GAC/B1H,OAAQ8H,cAAa,GACrB5G,KAAM8G,YAAW,GACjB9N,QAAS+N,eAAc,GACvBrG,GAAIsG,UAAS,GACbpG,MAAOqG,aAAY,GACnB9F,MAAO+F,aAAY,KAIRE,kBAAoBxF,IAACA,EAACkC,OAAO,CACxCqC,UAAWlC,WAAWkC,YACtBtK,UAAWwK,iBAAgB,GAC3BjK,WAAYkK,kBAAiB,GAC7BxJ,OAAQyJ,cAAa,GACrBlI,YAAamI,mBAAkB,GAC/B1H,OAAQ8H,cAAa,GACrB5G,KAAM8G,YAAW,GACjB9N,QAAS+N,eAAc,GACvBrG,GAAIsG,UAAS,GACbpG,MAAOqG,aAAY,GACnB9F,MAAO+F,aAAY,KAIRG,UAAYzF,IAACA,EAACkC,OAAO,CAEhCwD,eAAgBrD,WAAWxK,MAAK,GAGhC8N,mBAAoBtD,WAAW5H,SAAQ,GACvCmL,mBAAoBvD,WAAW3H,QAAO,GACtCmL,uBAAwBxD,WAAW1H,YAAW,GAC9CmL,sBAAuBzD,WAAWzH,WAAU,GAC5CmL,uBAAwB1D,WAAWC,YAAW,GAC9C0D,wBAAyB3D,WAAWxH,aAAY,GAChDoL,0BAA2B5D,WAAWtH,eAAc,GACpDmL,6BAA8B7D,WAAWrH,kBAAiB,GAC1DmL,0BAA2B9D,WAAWpH,eAAc,GAGpDmL,cAAe/D,WAAWlH,QAAO,GACjCkL,aAAchE,WAAWjH,QACzBkL,eAAgBjE,WAAWhH,UAC3BkL,WAAYlE,WAAW/G,MACvBkL,aAAcnE,WAAW9G,OAAM,GAC/BkL,eAAgBpE,WAAW7G,SAAQ,GACnCkL,YAAarE,WAAWlN,MAAK,GAC7BwR,cAAetE,WAAW1G,QAAO,GACjCiL,WAAYvE,WAAWzG,KAAI,GAC3BiL,mBAAoBxE,WAAWxG,YAAW,GAC1CiL,cAAezE,WAAWvG,QAAO,GACjCiL,aAAc1E,WAAWtG,OAAM,GAC/BiL,aAAc3E,WAAWrG,OAAM,GAC/BiL,sBAAuB5E,WAAWpG,eAAc,GAChDiL,qBAAsB7E,WAAWnG,cAAa,GAC9CiL,qBAAsB9E,WAAWlG,cAAa,GAC9CiL,sBAAuB/E,WAAW/F,gBAClC+K,qBAAsBhF,WAAW9F,eACjC+K,6BAA8BjF,WAAW7F,sBAAqB,GAG9D+K,kCAAmClF,WAAW3F,oBAAmB,GACjE8K,kCAAmCnF,WAAW1F,oBAAmB,GACjE8K,yBAA0BpF,WAAWzF,YAAW,GAChD8K,sBAAuBrF,WAAWxF,UAAS,GAC3C8K,uBAAwBtF,WAAWvF,WAAU,GAC7C8K,yBAA0BvF,WAAWtF,YAAW,GAChD8K,2BAA4BxF,WAAWpF,cAAa,GAGpD6K,cAAezF,WAAWa,cAAa,GACvC6E,YAAa1F,WAAWjF,MAAK,GAC7B4K,YAAa3F,WAAWhF,MAAK,GAC7B4K,oBAAqB5F,WAAW/E,aAAY,GAC5C4K,oBAAqB7F,WAAWc,oBAAmB,GAGnDgF,kBAAmB9F,WAAWe,WAAU,GACxCgF,kBAAmB/F,WAAWgB,WAAU,GACxCgF,qBAAsBhG,WAAWiB,cAAa,GAG9CgF,4BAA6BjG,WAAWkB,oBAAmB,GAC3DgF,kCAAmClG,WAAW1E,aAAY,GAC1D6K,4BAA6BnG,WAAWzE,QAAO,GAC/C6K,2BAA4BpG,WAAWxE,OAAM,GAC7C6K,iCAAkCrG,WAAWvE,YAAW,GACxD6K,8BAA+BtG,WAAWtE,SAAQ,GAClD6K,gCAAiCvG,WAAWrE,WAAU,GAGtD6K,kBAAmBxG,WAAWmB,WAAU,GACxCsF,iBAAkBzG,WAAWoB,UAAS,GACtCsF,gBAAiB1G,WAAWqB,SAAQ,GACpCsF,qBAAsB3G,WAAWsB,aAAY,GAG7CsF,iBAAkB5G,WAAWhE,YAAW,GACxC6K,iBAAkB7G,WAAW/D,YAAW,GACxC6K,gBAAiB9G,WAAW9D,WAAU,GACtC6K,qBAAsB/G,WAAW7D,gBAAe,GAChD6K,oBAAqBhH,WAAW5D,eAAc,GAC9C6K,qBAAsBjH,WAAW3D,gBAAe,GAChD6K,kBAAmBlH,WAAW1D,aAAY,GAC1C6K,2BAA4BnH,WAAWzD,qBAAoB,GAC3D6K,qBAAsBpH,WAAWxD,gBAAe,GAChD6K,kBAAmBrH,WAAWuB,kBAAiB,GAG/C+F,cAAetH,WAAWyB,UAAS,GACnC8F,aAAcvH,WAAW2B,SAAQ,GACjC6F,aAAcxH,WAAW4B,SAAQ,GACjC6F,mBAAoBzH,WAAW6B,cAAa,GAC5C6F,gBAAiB1H,WAAW8B,WAAU,GAGtC6F,UAAW3H,WAAW+B,UAAS,GAC/B6F,SAAU5H,WAAWgC,SAAQ,GAG7B6F,eAAgB7H,WAAWpD,SAAQ,GACnCkL,8BAA+B9H,WAAWnD,sBAAqB,GAC/DkL,cAAe/H,WAAWlD,QAAO,GACjCkL,sBAAuBhI,WAAWjD,eAAc,GAChDkL,yBAA0BjI,WAAWhD,kBAAiB,GACtDkL,iBAAkBlI,WAAW/C,YAAW,GAGxCkL,aAAcnI,WAAWiC,aAAY,GACrCmG,eAAgBpI,WAAW7C,UAAS,GACpCkL,eAAgBrI,WAAW5C,UAAS,GACpCkL,wBAAyBtI,WAAW3C,iBAAgB,GACpDkL,aAAcvI,WAAW1C,QAAO,GAChCkL,cAAexI,WAAWzC,QAAO,GACjCkL,qBAAsBzI,WAAWxC,eAAc,KAWpCkL,KAAOtF,UAAU1C,UAAUiI,MAAMxU,QAAQyU,KAW/C,SAASC,eAAeC,GAC7B,OAAO5F,mBAAmBxC,UAAUiI,MAAMG,EAC5C,CAWO,SAASC,cAAcD,GAC5B,OAAO3F,kBAAkBzC,UAAUiI,MAAMG,EAC3C,CA8BA,SAASjL,gBAAgB/G,EAAOkS,GAE9B,MAAMC,EAAenS,EAAMtE,KAAKuE,KAAK,KAG/BmS,EAAe,yBAAyBD,IAG9C,GAAInS,EAAMqS,OAASxL,MAAEyL,aAAaC,aAEhC,OAAIvS,EAAMwS,WAAa3L,MAAE4L,cAAcvT,UAC9B,CACLM,QAAS,GAAG4S,8BAKT,CACL5S,QAAS,GAAG4S,qBAAgCF,EAAQQ,iBAKxD,GAAI1S,EAAMqS,OAASxL,MAAEyL,aAAaK,QAE5B3S,EAAM0H,QAAQC,aAChB,MAAO,CACLnI,QAAS,GAAG4S,OAAkBpS,EAAM0H,QAAQC,2BAA2BuK,EAAQU,UAMrF,GAAI5S,EAAMqS,OAASxL,MAAEyL,aAAaO,cAAe,CAE/C,IAAIrT,EAAU,oCAAoC2S,OAYlD,OATAnS,EAAM8S,YAAYC,SAASrV,IACzB,MAAMsV,EAAQtV,EAAMoC,OAAO,GAAGN,QAAQ4J,QAAQ,KAC9C5J,IACc,IAAZwT,EACI,GAAGtV,EAAMoC,OAAO,GAAGN,YAAYyT,UAAUD,GACzC,GAAGtV,EAAMoC,OAAO,GAAGN,WAAW,IAI/B,CACLA,UAEH,CAGD,MAAO,CACLA,QAAS,GAAG4S,OAAkBF,EAAQQ,gBAE1C,CCtuFA,MAAMQ,oBAAoBC,MAQxB,WAAAC,CAAY5T,EAAS6T,GACnBC,QAGA/J,KAAK/J,QAAUA,EACf+J,KAAK9J,aAAeD,EAGhB6T,IACF9J,KAAK8J,WAAaA,EAErB,CAUD,QAAAE,CAASlU,GAqBP,OAnBAkK,KAAKlK,MAAQA,EAGTA,EAAMmU,OACRjK,KAAKiK,KAAOnU,EAAMmU,MAIhBnU,EAAMgU,aACR9J,KAAK8J,WAAahU,EAAMgU,YAItBhU,EAAMK,QACR6J,KAAK9J,aAAeJ,EAAMG,QAC1B+J,KAAK7J,MAAQL,EAAMK,OAId6J,IACR,EChCH,MAAMpG,cAAgBsQ,aAAa5S,eAG7B6S,YAAcC,mBAAmB9S,eAGjC+S,cAAgBC,qBAAqBhT,eAepC,SAASiT,WAAWC,GAAU,GAEnC,OAAOA,EAAUhZ,SAASoI,eAAiBA,aAC7C,CAoBO,SAAS6Q,cAAcC,EAAYF,GAAU,EAAO7M,GAAc,GAEvE,OAAOgN,cAELJ,WAAWC,GAEXI,gBAAgBF,EAAY/M,GAEhC,CAiEO,SAASkN,gBAAgBC,GAE9B,MAAMJ,EAAa,CAAA,EAGnB,GAAIvX,SAAS2X,GAEX,IAAK,MAAOjZ,EAAKsC,KAAUrC,OAAOiZ,QAAQD,GAAa,CAErD,MAAME,EAAkBb,YAAYtY,GAChCsY,YAAYtY,GAAKkB,MAAM,KACvB,GAIJiY,EAAgBC,QACd,CAACC,EAAKC,EAAM1B,IACTyB,EAAIC,GACHH,EAAgBzX,OAAS,IAAMkW,EAAQtV,EAAQ+W,EAAIC,IAAS,IAChET,EAEH,MAEDxV,IACE,EACA,oFAKJ,OAAOwV,CACT,CAgBO,SAASU,eAAenB,EAAMoB,EAAc1N,GAAc,GAE/D,IAAK4M,aAAajO,MAAMM,WACtB,OAAOyO,EAGT,IAEE,OAAO1L,WAAWsK,GAAMtM,GAAa2K,MAAM+C,EAC5C,CAAC,MAAOvV,GASP,MAPAQ,aACE,EACAR,EAAMS,OACN,oBAAoB0T,6BAIhB,IAAIN,YACR,oBAAoBM,4BACpB,IAEH,CACH,CAcO,SAASW,gBAAgBnC,EAAe9K,GAAc,GAE3D,IAAK4M,aAAajO,MAAMM,WACtB,OAAO6L,EAGT,IAEE,OAAO9K,EACH6K,eAAeC,GACfC,cAAcD,EACnB,CAAC,MAAO3S,GAKP,MAHAQ,aAAa,EAAGR,EAAMS,OAAQ,yCAGxB,IAAIoT,YAAY,wCAAyC,IAChE,CACH,CAoBO,SAAS2B,gBACdjO,OACAzK,UAAW,EACX2Y,gBAAiB,GAEjB,IAEE,IAAKpY,SAASkK,SAA6B,iBAAXA,OAE9B,OAAO,KAIT,MAAMmO,aACc,iBAAXnO,OACHkO,eACEE,KAAK,IAAIpO,WACTqO,KAAKpD,MAAMjL,QACbA,OAGAsO,mBAAqBC,kBACzBJ,aACAD,gBACA,GAIIM,cAAgBN,eAClBG,KAAKpD,MACHsD,kBAAkBJ,aAAcD,gBAAgB,IAChD,CAACO,EAAG3X,QACe,iBAAVA,OAAsBA,MAAMwK,WAAW,YAC1C8M,KAAK,IAAItX,UACTA,QAERuX,KAAKpD,MAAMqD,oBAGf,OAAO/Y,SAAW+Y,mBAAqBE,aACxC,CAAC,MAAO/V,GAEP,OAAO,IACR,CACH,CAqBA,SAASoU,aAAa7M,GAEpB,MAAM1E,EAAU,CAAA,EAGhB,IAAK,MAAOsR,EAAM7W,KAAStB,OAAOiZ,QAAQ1N,GACpCvL,OAAOC,UAAUC,eAAeC,KAAKmB,EAAM,cAElBuC,IAAvB0S,KAAKjV,EAAKqE,UAAiD,OAAvB4Q,KAAKjV,EAAKqE,SAEhDkB,EAAQsR,GAAQ5B,KAAKjV,EAAKqE,SAG1BkB,EAAQsR,GAAQ7W,EAAKe,MAIvBwE,EAAQsR,GAAQC,aAAa9W,GAKjC,OAAOuF,CACT,CAgBA,SAASgS,cAAcoB,EAAiBrB,GAEtC,GAAIvX,SAAS4Y,IAAoB5Y,SAASuX,GACxC,IAAK,MAAO7Y,EAAKsC,KAAUrC,OAAOiZ,QAAQL,GACxCqB,EAAgBla,GACdsB,SAASgB,KACRkW,cAActM,SAASlM,SACC8D,IAAzBoW,EAAgBla,GACZ8Y,cAAcoB,EAAgBla,GAAMsC,QAC1BwB,IAAVxB,EACEA,EACA4X,EAAgBla,IAAQ,KAKpC,OAAOka,CACT,CAsBA,SAASH,kBAAkBjT,EAAS4S,EAAgBS,GAiClD,OAAON,KAAKO,UAAUtT,GAhCG,CAACmT,EAAG3X,KAO3B,GALqB,iBAAVA,IACTA,EAAQA,EAAMnB,QAKG,mBAAVmB,GACW,iBAAVA,GACNA,EAAMwK,WAAW,aACjBxK,EAAM0K,SAAS,KACjB,CAEA,GAAI0M,EAEF,OAAOS,EAEH,YAAY7X,EAAQ,IAAI+X,WAAW,OAAQ,eAE3C,WAAW/X,EAAQ,IAAI+X,WAAW,OAAQ,cAG9C,MAAM,IAAItC,KAEb,CAGD,OAAOzV,CAAK,IAImC+X,WAC/CF,EAAqB,yBAA2B,qBAChD,GAEJ,CAoHA,SAAS5B,mBAAmB/M,EAAQ8M,EAAc,CAAA,EAAIgC,EAAY,IAqBhE,OApBAra,OAAOwB,KAAK+J,GAAQmM,SAAS3X,IAE3B,MAAMua,EAAQ/O,EAAOxL,QAGM,IAAhBua,EAAMjY,MAEfiW,mBAAmBgC,EAAOjC,EAAa,GAAGgC,KAAata,MAGvDsY,EAAYiC,EAAM1U,SAAW7F,GAAO,GAAGsa,KAAata,IAAM6X,UAAU,QAG3C/T,IAArByW,EAAM9R,aACR6P,EAAYiC,EAAM9R,YAAc,GAAG6R,KAAata,IAAM6X,UAAU,IAEnE,IAIIS,CACT,CAiBA,SAASG,qBAAqBjN,EAAQgN,EAAgB,IAkBpD,OAjBAvY,OAAOwB,KAAK+J,GAAQmM,SAAS3X,IAE3B,MAAMua,EAAQ/O,EAAOxL,QAGM,IAAhBua,EAAM5U,MAEf8S,qBAAqB8B,EAAO/B,GAGxB+B,EAAM5U,MAAMuG,SAAS,WACvBsM,EAAcjU,KAAKvE,EAEtB,IAIIwY,CACT,CCllBOgC,eAAeC,MAAIC,EAAKC,EAAiB,IAC9C,OAAO,IAAIC,SAAQ,CAACna,EAASoa,KAE3BC,mBAAmBJ,GAChBD,IAAIC,EAAKC,GAAiBI,IACzB,IAAIC,EAAe,GAGnBD,EAASE,GAAG,QAASC,IACnBF,GAAgBE,CAAK,IAIvBH,EAASE,GAAG,OAAO,KACZD,GACHH,EAAO,qCAITE,EAASI,KAAOH,EAChBva,EAAQsa,EAAS,GACjB,IAEHE,GAAG,SAAUhX,IACZ4W,EAAO5W,EAAM,GACb,GAER,CA0EA,SAAS6W,mBAAmBJ,GAC1B,OAAOA,EAAI5N,WAAW,SAAWsO,MAAQC,IAC3C,CCxGA,MAAMC,MAAQ,CACZnV,OAAQ,8BACRoV,eAAgB,CAAE,EAClBC,QAAS,GACTC,UAAW,IAeNjB,eAAekB,WAAWC,EAAmBC,GAClD,IACE,IAAIC,EAGJ,MAAMxV,EAAYyV,eAGZC,EAAelX,KAAAA,KAAKwB,EAAW,iBAC/B2V,EAAanX,KAAAA,KAAKwB,EAAW,cAOnC,IAJCf,GAAUA,WAACe,IAAcd,GAASA,UAACc,EAAW,CAAE4V,WAAW,KAIvD3W,GAAAA,WAAWyW,IAAiBJ,EAAkBvV,WACjD/C,IAAI,EAAG,yDAGPwY,QAAuBK,aACrBP,EACAC,EACAI,OAEG,CACL,IAAIG,GAAgB,EAGpB,MAAMC,EAAWvC,KAAKpD,MAAM4F,GAAYA,aAACN,GAAe,QAIxD,GAAIK,EAASE,SAAWxc,MAAMC,QAAQqc,EAASE,SAAU,CACvD,MAAMC,EAAY,CAAA,EAClBH,EAASE,QAAQ3E,SAAS6E,GAAOD,EAAUC,GAAK,IAChDJ,EAASE,QAAUC,CACpB,CAGD,MAAMjW,YAAEA,EAAWE,cAAEA,EAAaC,iBAAEA,GAClCkV,EACIc,EACJnW,EAAY5E,OAAS8E,EAAc9E,OAAS+E,EAAiB/E,OAK3D0a,EAASlW,UAAYyV,EAAkBzV,SAEzC7C,IACE,EACA,yEAEF8Y,GAAgB,GAEhBlc,OAAOwB,KAAK2a,EAASE,SAAW,CAAE,GAAE5a,SAAW+a,GAG/CpZ,IACE,EACA,+EAEF8Y,GAAgB,GAGhBA,GAAiB3V,GAAiB,IAAI5E,MAAM8a,IAC1C,IAAKN,EAASE,QAAQI,GAKpB,OAJArZ,IACE,EACA,eAAeqZ,iDAEV,CACR,IAKDP,EACFN,QAAuBK,aACrBP,EACAC,EACAI,IAGF3Y,IAAI,EAAG,uDAGPiY,MAAME,QAAUa,GAAAA,aAAaL,EAAY,QAGzCH,EAAiBO,EAASE,QAG1BhB,MAAMG,UAAYkB,kBAAkBrB,MAAME,SAE7C,OAIKoB,sBAAsBjB,EAAkBzV,QAAS2V,EACxD,CAAC,MAAO5X,GACP,MAAM,IAAI6T,YACR,8EACA,KACAK,SAASlU,EACZ,CACH,CASO,SAAS4Y,eACd,OAAOvB,MAAMG,SACf,CAWOjB,eAAesC,gBAAgBC,GAEpC,MAAMjW,EAAU8R,cAAc,CAC5B3S,WAAY,CACVC,QAAS6W,WAKPrB,WAAW5U,EAAQb,WAAYa,EAAQ6B,OAAOM,MACtD,CAoBO,SAAS6S,eACd,OAAOzb,gBAAgBqY,aAAazS,WAAWI,UACjD,CAgBAmU,eAAeoC,sBAAsB1W,EAAS2V,EAAiB,IAE7DP,MAAMC,eAAiB,CACrBrV,UACAoW,QAAST,GAGXxY,IAAI,EAAG,mCACP,IACE2Z,GAAaA,cACXnY,UAAKiX,eAAgB,iBACrBjC,KAAKO,UAAUkB,MAAMC,gBACrB,OAEH,CAAC,MAAOtX,GACP,MAAM,IAAI6T,YACR,4CACA,KACAK,SAASlU,EACZ,CACH,CAqBAuW,eAAe0B,aAAaP,EAAmBC,EAAoBI,GACjE,IAEE,MAAMP,EAC0B,WAA9BE,EAAkBzV,QACd,KACA,GAAGyV,EAAkBzV,UAE3B7C,IACE,EACA,iDAAiDoY,GAAa,aAIhE,MAAMtV,EAASwV,EAAkBxV,QAAUmV,MAAMnV,OAG3CwU,EAAiBsC,kBAAkBrB,GAGnCC,EAAiB,CAAA,EAoDvB,OAjDAP,MAAME,eACEZ,QAAQsC,IAAI,IAEbvB,EAAkBrV,YAAY3B,KAAKwY,GACpCC,aACE3B,EAAY,GAAGtV,KAAUsV,KAAa0B,IAAO,GAAGhX,KAAUgX,IAC1DxC,EACAkB,GACA,QAIDF,EAAkBnV,cAAc7B,KAAK0Y,GACtCD,aACS,QAAPC,EACI5B,EACE,GAAGtV,UAAesV,aAAqB4B,IACvC,GAAGlX,kBAAuBkX,IAC5B5B,EACE,GAAGtV,KAAUsV,aAAqB4B,IAClC,GAAGlX,aAAkBkX,IAC3B1C,EACAkB,QAIDF,EAAkBlV,iBAAiB9B,KAAK2Y,GACzCF,aACE3B,EACI,GAAGtV,WAAgBsV,gBAAwB6B,IAC3C,GAAGnX,sBAA2BmX,IAClC3C,EACAkB,QAIDF,EAAkBjV,cAAc/B,KAAKwY,GACtCC,aAAa,GAAGD,IAAMxC,QAG1B9V,KAAK,OAGPyW,MAAMG,UAAYkB,kBAAkBrB,MAAME,SAG1CwB,GAAAA,cAAchB,EAAYV,MAAME,SAGzBK,CACR,CAAC,MAAO5X,GACP,MAAM,IAAI6T,YACR,uDACA,KACAK,SAASlU,EACZ,CACH,CAsBAuW,eAAe4C,aACbG,EACA5C,EACAkB,EACA2B,GAAmB,GAGfD,EAAOvQ,SAAS,SAClBuQ,EAASA,EAAO1F,UAAU,EAAG0F,EAAO7b,OAAS,IAE/C2B,IAAI,EAAG,6BAA6Bka,QAGpC,MAAMxC,QAAiBN,MAAI,GAAG8C,OAAa5C,GAG3C,GAA4B,MAAxBI,EAAS9C,YAA8C,iBAAjB8C,EAASI,KAAkB,CACnE,GAAIU,EAAgB,CAElBA,EADmB4B,mBAAmBF,IACT,CAC9B,CACD,OAAOxC,EAASI,IACjB,CAGD,GAAIqC,EACF,MAAM,IAAI1F,YACR,+BAA+ByF,2EAAgFxC,EAAS9C,eACxH,KACAE,SAAS4C,GAEX1X,IACE,EACA,+BAA+Bka,6DAGrC,CAmBA,SAASN,kBAAkBrB,GAEzB,MAAM/M,EAAY+M,EAAmB/S,KAC/BiG,EAAY8M,EAAmB9S,KAGrC,GAAI+F,GAAaC,EACf,IAQE,MAAO,CACL4O,MAPiB,IAAIC,gCAAgB,CACrC9U,KAAMgG,EACN/F,KAAMgG,IAMN5F,QAAS0S,EAAmB1S,QAE/B,CAAC,MAAOjF,GACP,MAAM,IAAI6T,YACR,0CACA,KACAK,SAASlU,EACZ,CAIH,MAAO,EACT,CAWA,SAAS0Y,kBAAkBiB,GACzB,OAAOA,EACJ/F,UAAU,EAAG+F,EAAa5P,QAAQ,OAClC6P,QAAQ,KAAM,IACdA,QAAQ,KAAM,IACdA,QAAQ,MAAO,IACf1c,MACL,CAYA,SAASsc,mBAAmBK,GAC1B,OAAOA,EAAWD,QAChB,qEACA,GAEJ,CChdO,SAASE,kBACdC,WAAWC,WAAa,WACtB,MAAO,CAAEC,SAAU,EACvB,CACA,CAcO1D,eAAe2D,YAAYC,EAAeC,GAE/C,MAAM3F,WAAEA,EAAU4F,WAAEA,EAAUC,MAAEA,EAAKC,KAAEA,GAASR,WAIhDA,WAAWS,cAAgBF,GAAM,EAAO,CAAE,EAAE7F,KAG5CrP,OAAOqV,kBAAmB,EAC1BF,EAAKR,WAAWW,MAAMze,UAAW,QAAQ,SAAU0e,EAASC,EAAaC,KAEvED,EAAcN,EAAMM,EAAa,CAC/BE,UAAW,CACTC,SAAS,GAEXC,YAAa,CACXC,OAAQ,CACNC,MAAO,CACLH,SAAS,KAOfI,QAAS,CAAE,KAGAF,QAAU,IAAIvH,SAAQ,SAAUuH,GAC3CA,EAAOG,WAAY,CACzB,IAGShW,OAAOiW,qBACVjW,OAAOiW,mBAAqBtB,WAAWuB,SAASpR,KAAM,UAAU,KAC9D9E,OAAOqV,kBAAmB,CAAI,KAIlCE,EAAQ/a,MAAMsK,KAAM,CAAC0Q,EAAaC,GACtC,IAEEN,EAAKR,WAAWwB,OAAOtf,UAAW,QAAQ,SAAU0e,EAASa,EAAO3Y,GAClE8X,EAAQ/a,MAAMsK,KAAM,CAACsR,EAAO3Y,GAChC,IAGE,MAAM+G,EAAoB,CACxB4R,MAAO,CAELJ,WAAW,EAEX9X,OAAQ6W,EAAc7W,OACtBC,MAAO4W,EAAc5W,OAEvBuX,UAAW,CAETC,SAAS,IAKPH,EAAc,IAAIa,SAAS,UAAUtB,EAAcvX,QAArC,GAGdmB,EAAe,IAAI0X,SAAS,UAAUtB,EAAcpW,eAArC,GAGf2X,EAAepB,GACnB,EACAvW,EACA6W,EAEAhR,GAII+R,EAAgBvB,EAAmB/V,SACrC,IAAIoX,SAAS,UAAUrB,EAAmB/V,WAA1C,GACA,KAGA+V,EAAmBhW,YACrB,IAAIqX,SAAS,UAAWrB,EAAmBhW,WAA3C,CAAuDwW,GAIzD,MAAM9W,EAAgB,IAAI2X,SAAS,UAAUtB,EAAcrW,gBAArC,GAGlBA,GACFuW,EAAWvW,GAIbiW,WAAWI,EAAchX,QAAQ,YAAauY,EAAcC,GAG5D,MAAMC,EAAS/f,MAAMgB,KACnB7B,SAAS6gB,iBAAiB,sCAItBlF,QAAQmF,KAAK,CACjBnF,QAAQsC,IACN2C,EAAOlb,KAAKqb,GACVA,EAAMC,UAAoC,IAAxBD,EAAME,cACpBtF,QAAQna,UACR,IAAIma,SAASna,GACXuf,EAAMG,iBAAiB,OAAQ1f,EAAS,CAAE2f,MAAM,SAK1D,IAAIxF,SAASna,GAAY4f,WAAW5f,EAAS,SAI/C,MAAM6f,EAAiB5H,IAGvB,IAAK,MAAMY,KAAQgH,EACmB,mBAAzBA,EAAehH,WACjBgH,EAAehH,GAK1BgF,EAAWN,WAAWS,eAGtBT,WAAWS,cAAgB,EAC7B,CChJA,MAAM8B,aAAelE,GAAYA,aAC/BxX,UAAK/F,YAAW,YAAa,iBAC7B,QAIF,IAAI0hB,QAAU,KAmCPhG,eAAeiG,cAAcC,GAElC,MAAM1V,MAAEA,EAAKP,MAAEA,GAAUiO,cAGjB9P,OAAQ+X,KAAiBC,GAAiB5V,EAG5C6V,EAAgB,CACpB5V,UAAUR,EAAMK,kBAAmB,QACnCgW,YAAa,MACbxd,KAAMod,GAAiB,GACvBK,cAAc,EACdC,eAAe,EACfC,cAAc,EACdC,oBAAoB,EACpBC,gBAAiB,QACbR,GAAgBC,GAItB,IAAKJ,QAAS,CAEZ,IAAIY,EAAW,EACf,MAAMC,EAAc7G,UAClB,IACEnX,IACE,EACA,oEAAoE+d,OAItEZ,cAAgB9a,UAAU4b,OAAOT,EAClC,CAAC,MAAO5c,GAQP,GAPAD,aACE,EACAC,EACA,oDAIEmd,EAAW,IAOb,MAAMnd,EANNZ,IAAI,EAAG,sCAAsC+d,uBAGvC,IAAIxG,SAASG,GAAasF,WAAWtF,EAAU,aAC/CsG,GAIT,GAGH,UAEQA,IAGyB,UAA3BR,EAAc5V,UAChB5H,IAAI,EAAG,6CAILsd,GACFtd,IAAI,EAAG,4CAEV,CAAC,MAAOY,GACP,MAAM,IAAI6T,YACR,gEACA,KACAK,SAASlU,EACZ,CAGD,IAAKuc,QACH,MAAM,IAAI1I,YAAY,2CAA4C,IAErE,CAGD,OAAO0I,OACT,CAQOhG,eAAe+G,eAEhBf,SAAWA,QAAQgB,iBACfhB,QAAQiB,QAEhBjB,QAAU,KACVnd,IAAI,EAAG,gCACT,CAgBOmX,eAAekH,QAAQC,GAE5B,IAAKnB,UAAYA,QAAQgB,UACvB,MAAM,IAAI1J,YAAY,0CAA2C,KAgBnE,GAZA6J,EAAaC,WAAapB,QAAQkB,gBAG5BC,EAAaC,KAAKC,iBAAgB,SAGlCC,gBAAgBH,EAAaC,MAGnCG,eAAeJ,EAAaC,OAGvBD,EAAaC,MAAQD,EAAaC,KAAKI,WAC1C,MAAM,IAAIlK,YAAY,2CAA4C,IAEtE,CAkBO0C,eAAeyH,UAAUN,EAAcO,GAAY,GACxD,IACE,GAAIP,EAAaC,OAASD,EAAaC,KAAKI,WAgB1C,OAfIE,SAEIP,EAAaC,KAAKO,KAAK,cAAe,CAC1CC,UAAW,2BAIPN,gBAAgBH,EAAaC,aAG7BD,EAAaC,KAAKS,UAAS,KAC/BpjB,SAASqjB,KAAKC,UACZ,4DAA4D,KAG3D,CAEV,CAAC,MAAOte,GACPD,aACE,EACAC,EACA,yBAAyB0d,EAAaa,mDAIxCb,EAAac,UAAY/J,aAAa7O,KAAKG,UAAY,CACxD,CACD,OAAO,CACT,CAiBOwQ,eAAekI,iBAAiBd,EAAMvD,GAE3C,MAAMsE,EAAoB,GAGpBpa,EAAY8V,EAAmB9V,UACrC,GAAIA,EAAW,CACb,MAAMqa,EAAa,GAUnB,GAPIra,EAAU8F,IACZuU,EAAWre,KAAK,CACdse,QAASta,EAAU8F,KAKnB9F,EAAUgG,MACZ,IAAK,MAAMtJ,KAAQsD,EAAUgG,MAAO,CAClC,MAAMuU,GAAU7d,EAAK6H,WAAW,QAGhC8V,EAAWre,KACTue,EACI,CACED,QAASxG,GAAAA,aAAahc,gBAAgB4E,GAAO,SAE/C,CACEyV,IAAKzV,GAGd,CAIH,IAAK,MAAM8d,KAAcH,EACvB,IACED,EAAkBpe,WAAWqd,EAAKoB,aAAaD,GAChD,CAAC,MAAO9e,GACPD,aAAa,EAAGC,EAAO,8CACxB,CAEH2e,EAAWlhB,OAAS,EAGpB,MAAMuhB,EAAc,GACpB,GAAI1a,EAAU+F,IAAK,CACjB,MAAM4U,EAAa3a,EAAU+F,IAAI6U,MAAM,uBACvC,GAAID,EAEF,IAAK,IAAIE,KAAiBF,EACpBE,IACFA,EAAgBA,EACbvF,QAAQ,OAAQ,IAChBA,QAAQ,UAAW,IACnBA,QAAQ,KAAM,IACdA,QAAQ,KAAM,IACdA,QAAQ,IAAK,IACbA,QAAQ,MAAO,IACf1c,OAGCiiB,EAActW,WAAW,QAC3BmW,EAAY1e,KAAK,CACfmW,IAAK0I,IAEE/E,EAAmBjW,oBAC5B6a,EAAY1e,KAAK,CACfjE,KAAMD,gBAAgB+iB,MAQhCH,EAAY1e,KAAK,CACfse,QAASta,EAAU+F,IAAIuP,QAAQ,sBAAuB,KAAO,MAI/D,IAAK,MAAMwF,KAAeJ,EACxB,IACEN,EAAkBpe,WAAWqd,EAAK0B,YAAYD,GAC/C,CAAC,MAAOpf,GACPD,aACE,EACAC,EACA,+CAEH,CAEHgf,EAAYvhB,OAAS,CACtB,CACF,CACD,OAAOihB,CACT,CAeOnI,eAAe+I,mBAAmB3B,EAAMe,GAC7C,IACE,IAAK,MAAMa,KAAYb,QACfa,EAASC,gBAIX7B,EAAKS,UAAS,KAElB,GAA0B,oBAAfrE,WAA4B,CAErC,MAAM0F,EAAY1F,WAAW2F,OAG7B,GAAI7jB,MAAMC,QAAQ2jB,IAAcA,EAAUhiB,OAExC,IAAK,MAAMkiB,KAAYF,EACrBE,GAAYA,EAASC,UAErB7F,WAAW2F,OAAOnf,OAGvB,CAGD,SAAUsf,GAAmB7kB,SAAS8kB,qBAAqB,WAErD,IAAMC,GAAkB/kB,SAAS8kB,qBAAqB,aAElDE,GAAiBhlB,SAAS8kB,qBAAqB,QAGzD,IAAK,MAAMG,IAAW,IACjBJ,KACAE,KACAC,GAEHC,EAAQC,QACT,GAEJ,CAAC,MAAOlgB,GACPD,aAAa,EAAGC,EAAO,8CACxB,CACH,CAYAuW,eAAesH,gBAAgBF,SAEvBA,EAAKwC,WAAW7D,aAAc,CAAE6B,UAAW,2BAG3CR,EAAKoB,aAAa,CAAE1iB,KAAMuE,KAAIA,KAACiX,eAAgB,sBAG/C8F,EAAKS,SAAStE,gBACtB,CAWA,SAASgE,eAAeH,GAEtB,MAAM5W,MAAEA,GAAU0N,aAGlBkJ,EAAK3G,GAAG,aAAaT,UAGfoH,EAAKI,UAER,IAIChX,EAAMpC,QAAUoC,EAAMG,iBACxByW,EAAK3G,GAAG,WAAY7W,IAClBR,QAAQP,IAAI,WAAWe,EAAQ+W,SAAS,GAG9C,CC/cA,IAAAkJ,YAAe,IAAM,yXCINC,YAACvd,GAAQ,8LAQlBsd,8EAIEtd,wCCaDyT,eAAe+J,gBAAgB3C,EAAMxD,EAAeC,GAEzD,MAAMsE,EAAoB,GAE1B,IACE,IAAI6B,GAAQ,EAGZ,GAAIpG,EAAcrX,IAAK,CAIrB,GAHA1D,IAAI,EAAG,mCAGoB,QAAvB+a,EAAcxd,KAChB,OAAOwd,EAAcrX,IAIvByd,GAAQ,QAGF5C,EAAKwC,WAAWE,YAAYlG,EAAcrX,KAAM,CACpDqb,UAAW,oBAEnB,MACM/e,IAAI,EAAG,2CAGDue,EAAKS,SAASlE,YAAaC,EAAeC,GAMlDsE,EAAkBpe,cACNme,iBAAiBd,EAAMvD,IAInC,MAAMoG,QAAaC,cAAc9C,EAAM4C,EAAOpG,EAAc3W,QAGtDkd,EAAEA,EAACC,EAAEA,SAAYC,eAAejD,GAGhCkD,EAAiBriB,KAAKsiB,IAC1BtiB,KAAKuiB,KAAKP,EAAKQ,aAAe7G,EAAc7W,SAIxC2d,EAAgBziB,KAAKsiB,IACzBtiB,KAAKuiB,KAAKP,EAAKU,YAAc/G,EAAc5W,QAU7C,IAAI4d,EAEJ,aARMxD,EAAKyD,YAAY,CACrB9d,OAAQud,EACRtd,MAAO0d,EACPI,kBAAmBd,EAAQ,EAAIe,WAAWnH,EAAc3W,SAKlD2W,EAAcxd,MACpB,IAAK,MACHwkB,QAAeI,WAAW5D,GAC1B,MACF,IAAK,MACL,IAAK,OACHwD,QAAeK,aACb7D,EACAxD,EAAcxd,KACd,CACE4G,MAAO0d,EACP3d,OAAQud,EACRH,IACAC,KAEFxG,EAAcnW,sBAEhB,MACF,IAAK,MACHmd,QAAeM,WACb9D,EACAkD,EACAI,EACA9G,EAAcnW,sBAEhB,MACF,QACE,MAAM,IAAI6P,YACR,uCAAuCsG,EAAcxd,QACrD,KAMN,aADM2iB,mBAAmB3B,EAAMe,GACxByC,CACR,CAAC,MAAOnhB,GAEP,aADMsf,mBAAmB3B,EAAMe,GACxB1e,CACR,CACH,CAcAuW,eAAeqK,eAAejD,GAC5B,OAAOA,EAAK+D,MAAM,oBAAqBzB,IACrC,MAAMS,EAAEA,EAACC,EAAEA,EAACpd,MAAEA,EAAKD,OAAEA,GAAW2c,EAAQ0B,wBACxC,MAAO,CACLjB,IACAC,IACApd,QACAD,OAAQ9E,KAAKojB,MAAMte,EAAS,EAAIA,EAAS,KAC1C,GAEL,CAmBAiT,eAAekK,cAAc9C,EAAM4C,EAAO/c,GAExC,OAAO+c,QACG5C,EAAKS,UAAU5a,IACnB,MAAMqe,EAAa7mB,SAAS8mB,cAC1B,sCAIId,EAAca,EAAWve,OAAOye,QAAQ1jB,MAAQmF,EAChD0d,EAAaW,EAAWte,MAAMwe,QAAQ1jB,MAAQmF,EAUpD,OANAxI,SAASqjB,KAAK2D,MAAMC,KAAOze,EAI3BxI,SAASqjB,KAAK2D,MAAME,OAAS,MAEtB,CACLlB,cACAE,aACD,GACAI,WAAW9d,UACRma,EAAKS,UAAS,KAElB,MAAM4C,YAAEA,EAAWE,WAAEA,GAAe9b,OAAO2U,WAAW2F,OAAO,GAO7D,OAFA1kB,SAASqjB,KAAK2D,MAAMC,KAAO,EAEpB,CACLjB,cACAE,aACD,GAET,CAaA3K,eAAegL,WAAW5D,GACxB,OAAOA,EAAK+D,MACV,gCACCzB,GAAYA,EAAQkC,WAEzB,CAkBA5L,eAAeiL,aAAa7D,EAAMhhB,EAAMylB,EAAMpe,GAC5C,OAAO2S,QAAQmF,KAAK,CAClB6B,EAAK0E,WAAW,CACd1lB,OACAylB,OACAE,SAAU,SACVC,UAAU,EACVC,kBAAkB,EAClBC,uBAAuB,KACV,QAAT9lB,EAAiB,CAAE+lB,QAAS,IAAO,CAAA,EAEvCC,eAAwB,OAARhmB,IAElB,IAAIga,SAAQ,CAACiM,EAAUhM,IACrBwF,YACE,IAAMxF,EAAO,IAAI/C,YAAY,wBAAyB,OACtD7P,GAAwB,SAIhC,CAiBAuS,eAAekL,WAAW9D,EAAMra,EAAQC,EAAOS,GAE7C,aADM2Z,EAAKkF,iBAAiB,UACrBlF,EAAKmF,IAAI,CAEdxf,OAAQA,EAAS,EACjBC,QACA+e,SAAU,SACVrd,QAASjB,GAAwB,MAErC,CCzRA,IAAI4B,KAAO,KAGX,MAAMmd,UAAY,CAChBC,iBAAkB,EAClBC,iBAAkB,EAClBC,eAAgB,EAChBC,eAAgB,EAChBC,mBAAoB,EACpBC,uBAAwB,EACxBC,2BAA4B,EAC5BC,UAAW,EACXC,iBAAkB,GAqBbjN,eAAekN,SAASC,EAAajH,SAEpCD,cAAcC,GAEpB,IAME,GALArd,IACE,EACA,8CAA8CskB,EAAY7d,mBAAmB6d,EAAY5d,eAGvFF,KAKF,YAJAxG,IACE,EACA,yEAMAskB,EAAY7d,WAAa6d,EAAY5d,aACvC4d,EAAY7d,WAAa6d,EAAY5d,YAIvCF,KAAO,IAAI+d,KAAAA,KAAK,IAEXC,SAASF,GACZ9f,IAAK8f,EAAY7d,WACjBhC,IAAK6f,EAAY5d,WACjB+d,qBAAsBH,EAAY1d,eAClC8d,oBAAqBJ,EAAYzd,cACjC8d,qBAAsBL,EAAYxd,eAClC8d,kBAAmBN,EAAYvd,YAC/B8d,0BAA2BP,EAAYtd,oBACvC8d,mBAAoBR,EAAYrd,eAChC8d,sBAAsB,IAIxBve,KAAKoR,GAAG,WAAWT,MAAOgJ,IAExB,MAAM6E,QAAoBpG,UAAUuB,GAAU,GAC9CngB,IACE,EACA,yBAAyBmgB,EAAShB,gDAAgD6F,KACnF,IAGHxe,KAAKoR,GAAG,kBAAkB,CAACqN,EAAU9E,KACnCngB,IACE,EACA,yBAAyBmgB,EAAShB,0CAEpCgB,EAAS5B,KAAO,IAAI,IAGtB,MAAM2G,EAAmB,GAEzB,IAAK,IAAIC,EAAI,EAAGA,EAAIb,EAAY7d,WAAY0e,IAC1C,IACE,MAAMhF,QAAiB3Z,KAAK4e,UAAUC,QACtCH,EAAiBhkB,KAAKif,EACvB,CAAC,MAAOvf,GACPD,aAAa,EAAGC,EAAO,+CACxB,CAIHskB,EAAiB5Q,SAAS6L,IACxB3Z,KAAK8e,QAAQnF,EAAS,IAGxBngB,IACE,EACA,4BAA2BklB,EAAiB7mB,OAAS,SAAS6mB,EAAiB7mB,oCAAsC,KAExH,CAAC,MAAOuC,GACP,MAAM,IAAI6T,YACR,6DACA,KACAK,SAASlU,EACZ,CACH,CAYOuW,eAAeoO,WAIpB,GAHAvlB,IAAI,EAAG,6DAGHwG,KAAM,CAER,IAAK,MAAMgf,KAAUhf,KAAKif,KACxBjf,KAAK8e,QAAQE,EAAOrF,UAIjB3Z,KAAKkf,kBACFlf,KAAKga,UACXxgB,IAAI,EAAG,4CAETwG,KAAO,IACR,OAGK0X,cACR,CAmBO/G,eAAewO,SAASliB,GAC7B,IAAImiB,EAEJ,IAYE,GAXA5lB,IAAI,EAAG,gDAGL2jB,UAAUC,iBAGRngB,EAAQ+C,KAAKb,cACfkgB,gBAIGrf,KACH,MAAM,IAAIiO,YACR,uDACA,KAKJ,MAAMqR,EAAiBpnB,cAGvB,IACEsB,IAAI,EAAG,qCAGP4lB,QAAqBpf,KAAK4e,UAAUC,QAGhC5hB,EAAQ6B,OAAOK,cACjB3F,IACE,EACA,gBAAeyD,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,IACzE,kCAAkCmZ,SAGvC,CAAC,MAAOllB,GACP,MAAM,IAAI6T,YACR,UACEhR,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,0DACJmZ,SACxD,KACAhR,SAASlU,EACZ,CAGD,GAFAZ,IAAI,EAAG,qCAEF4lB,EAAarH,KAGhB,MADAqH,EAAaxG,UAAY3b,EAAQ+C,KAAKG,UAAY,EAC5C,IAAI8N,YACR,mEACA,KAIJzU,IACE,EACA,yBAAyB4lB,EAAazG,2CAIxC,MAAM4G,EAAgBrnB,cAGhBsnB,QAAqB9E,gBACzB0E,EAAarH,KACb9a,EAAQH,OACRG,EAAQoB,aAIV,GAAImhB,aAAwBtR,MAkB1B,KAN6B,0BAAzBsR,EAAajlB,UAEf6kB,EAAaxG,UAAY3b,EAAQ+C,KAAKG,UAAY,EAClDif,EAAarH,KAAO,MAIE,iBAAtByH,EAAajR,MACY,0BAAzBiR,EAAajlB,QAEP,IAAI0T,YACR,UACEhR,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,mHAE5DmI,SAASkR,GAEL,IAAIvR,YACR,UACEhR,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,sCACxBoZ,UACpCjR,SAASkR,GAwBf,OAnBIviB,EAAQ6B,OAAOK,cACjB3F,IACE,EACA,gBAAeyD,EAAQkJ,UAAY,YAAYlJ,EAAQkJ,gBAAkB,IACzE,sCAAsCoZ,UAK1Cvf,KAAK8e,QAAQM,GAGbjC,UAAUQ,WAAa4B,IACvBpC,UAAUS,iBACRT,UAAUQ,YAAcR,UAAUE,iBAEpC7jB,IAAI,EAAG,4BAA4B+lB,UAG5B,CACLhE,OAAQiE,EACRviB,UAEH,CAAC,MAAO7C,GAQP,OAPE+iB,UAAUG,eAGR8B,GACFpf,KAAK8e,QAAQM,GAGThlB,CACP,CACH,CAqBO,SAASqlB,eACd,OAAOtC,SACT,CAUO,SAASuC,kBACd,MAAO,CACL1hB,IAAKgC,KAAKhC,IACVC,IAAK+B,KAAK/B,IACVghB,KAAMjf,KAAK2f,UACXC,UAAW5f,KAAK6f,UAChBC,WAAY9f,KAAK2f,UAAY3f,KAAK6f,UAClCE,gBAAiB/f,KAAKggB,qBACtBC,eAAgBjgB,KAAKkgB,oBACrBC,mBAAoBngB,KAAKogB,wBACzBC,gBAAiBrgB,KAAKqgB,gBAAgBxoB,OACtCyoB,YACEtgB,KAAK2f,UACL3f,KAAK6f,UACL7f,KAAKggB,qBACLhgB,KAAKkgB,oBACLlgB,KAAKogB,wBACLpgB,KAAKqgB,gBAAgBxoB,OAE3B,CASA,SAASwnB,eACP,MAAMrhB,IACJA,EAAGC,IACHA,EAAGghB,KACHA,EAAIW,UACJA,EAASE,WACTA,EAAUC,gBACVA,EAAeE,eACfA,EAAcE,mBACdA,EAAkBE,gBAClBA,EAAeC,YACfA,GACEZ,kBAEJlmB,IAAI,EAAG,2DAA2DwE,MAClExE,IAAI,EAAG,2DAA2DyE,MAClEzE,IAAI,EAAG,wCAAwCylB,MAC/CzlB,IAAI,EAAG,wCAAwComB,MAC/CpmB,IACE,EACA,+DAA+DsmB,MAEjEtmB,IACE,EACA,0DAA0DumB,MAE5DvmB,IACE,EACA,yDAAyDymB,MAE3DzmB,IACE,EACA,2DAA2D2mB,MAE7D3mB,IACE,EACA,2DAA2D6mB,MAE7D7mB,IAAI,EAAG,uCAAuC8mB,KAChD,CAWA,SAAStC,SAASF,GAChB,MAAO,CAcLyC,OAAQ5P,UAEN,MAAMmH,EAAe,CACnBa,GAAIvS,KAAAA,KAEJwS,UAAWhgB,KAAKE,MAAMF,KAAK4nB,UAAY1C,EAAY3d,UAAY,KAGjE,IAEE,MAAMsgB,EAAYlpB,iBAclB,aAXMsgB,QAAQC,GAGdte,IACE,EACA,yBAAyBse,EAAaa,6CACpCphB,iBAAmBkpB,QAKhB3I,CACR,CAAC,MAAO1d,GAKP,MAJAZ,IACE,EACA,yBAAyBse,EAAaa,qDAElCve,CACP,GAgBHsmB,SAAU/P,MAAOmH,GAiBVA,EAAaC,KASdD,EAAaC,KAAKI,YACpB3e,IACE,EACA,yBAAyBse,EAAaa,yDAEjC,GAILb,EAAaC,KAAK4I,YAAYC,UAChCpnB,IACE,EACA,yBAAyBse,EAAaa,wDAEjC,KAKPmF,EAAY3d,aACV2X,EAAac,UAAYkF,EAAY3d,aAEvC3G,IACE,EACA,yBAAyBse,EAAaa,yCAAyCmF,EAAY3d,yCAEtF,IAlCP3G,IACE,EACA,yBAAyBse,EAAaa,sDAEjC,GA8CXqB,QAASrJ,MAAOmH,IAMd,GALAte,IACE,EACA,yBAAyBse,EAAaa,8BAGpCb,EAAaC,OAASD,EAAaC,KAAKI,WAC1C,IAEEL,EAAaC,KAAK8I,mBAAmB,aACrC/I,EAAaC,KAAK8I,mBAAmB,WACrC/I,EAAaC,KAAK8I,mBAAmB,uBAG/B/I,EAAaC,KAAKH,OACzB,CAAC,MAAOxd,GAKP,MAJAZ,IACE,EACA,yBAAyBse,EAAaa,mDAElCve,CACP,CACF,EAGP,CCjkBO,SAAS0mB,SAAShqB,GAEvB,MAAM0I,EAAS,IAAIuhB,MAAAA,MAAM,IAAIvhB,OAM7B,OAHewhB,UAAUxhB,GAGXshB,SAAShqB,EAAO,CAAEmqB,SAAU,CAAC,kBAC7C,CCVA,IAAI3iB,oBAAqB,EAqBlBqS,eAAeuQ,aAAajkB,GAEjC,IAAIA,IAAWA,EAAQH,OAwCrB,MAAM,IAAImR,YACR,kKACA,WAxCIkT,YACJ,CAAErkB,OAAQG,EAAQH,OAAQuB,YAAapB,EAAQoB,cAC/CsS,MAAOvW,EAAOuT,KAEZ,GAAIvT,EACF,MAAMA,EAIR,MAAMoD,IAAEA,EAAGJ,QAAEA,EAAOrG,KAAEA,GAAS4W,EAAK1Q,QAAQH,OAG5C,IACMU,EAEF2V,GAAaA,cACX,GAAG/V,EAAQ/F,MAAM,KAAKsD,SAAW,cACjC9D,UAAU8W,EAAK4N,OAAQxkB,IAIzBoc,GAAaA,cACX/V,GAAW,SAASrG,IACX,QAATA,EAAiBC,OAAOC,KAAK0W,EAAK4N,OAAQ,UAAY5N,EAAK4N,OAGhE,CAAC,MAAOnhB,GACP,MAAM,IAAI6T,YACR,sCACA,KACAK,SAASlU,EACZ,OAGK2kB,UAAU,GASxB,CAsBOpO,eAAeyQ,YAAYnkB,GAEhC,KAAIA,GAAWA,EAAQH,QAAUG,EAAQH,OAAOK,OA4E9C,MAAM,IAAI8Q,YACR,+GACA,KA9EmD,CAErD,MAAMoT,EAAiB,GAGvB,IAAK,IAAIC,KAAQrkB,EAAQH,OAAOK,MAAM9F,MAAM,MAAQ,GAClDiqB,EAAOA,EAAKjqB,MAAM,KACE,IAAhBiqB,EAAKzpB,OACPwpB,EAAe3mB,KACbymB,YACE,CACErkB,OAAQ,IACHG,EAAQH,OACXC,OAAQukB,EAAK,GACblkB,QAASkkB,EAAK,IAEhBjjB,YAAapB,EAAQoB,cAEvB,CAACjE,EAAOuT,KAEN,GAAIvT,EACF,MAAMA,EAIR,MAAMoD,IAAEA,EAAGJ,QAAEA,EAAOrG,KAAEA,GAAS4W,EAAK1Q,QAAQH,OAG5C,IACMU,EAEF2V,GAAaA,cACX,GAAG/V,EAAQ/F,MAAM,KAAKsD,SAAW,cACjC9D,UAAU8W,EAAK4N,OAAQxkB,IAIzBoc,GAAaA,cACX/V,EACS,QAATrG,EACIC,OAAOC,KAAK0W,EAAK4N,OAAQ,UACzB5N,EAAK4N,OAGd,CAAC,MAAOnhB,GACP,MAAM,IAAI6T,YACR,sCACA,KACAK,SAASlU,EACZ,MAKPZ,IAAI,EAAG,uDAKX,MAAM+nB,QAAqBxQ,QAAQyQ,WAAWH,SAGxCtC,WAGNwC,EAAazT,SAAQ,CAACyN,EAAQxN,KAExBwN,EAAOkG,QACTtnB,aACE,EACAohB,EAAOkG,OACP,+BAA+B1T,EAAQ,sCAE1C,GAEP,CAMA,CAoCO4C,eAAewQ,YAAYO,EAAcC,GAC9C,IAEE,IAAKlqB,SAASiqB,GACZ,MAAM,IAAIzT,YACR,iFACA,KAKJ,MAAMhR,EAAU8R,cACd,CACEjS,OAAQ4kB,EAAa5kB,OACrBuB,YAAaqjB,EAAarjB,cAE5B,GAIIkW,EAAgBtX,EAAQH,OAM9B,GAHAtD,IAAI,EAAG,2CAGsB,OAAzB+a,EAAcxX,OAAiB,CAGjC,IAAI6kB,EAFJpoB,IAAI,EAAG,mDAGP,IAEEooB,EAAcpP,GAAYA,aACxBhc,gBAAgB+d,EAAcxX,QAC9B,OAEH,CAAC,MAAO3C,GACP,MAAM,IAAI6T,YACR,mDACA,KACAK,SAASlU,EACZ,CAGD,GAAIma,EAAcxX,OAAOoG,SAAS,QAEhCoR,EAAcrX,IAAMwS,eAAe,MAAOkS,OACrC,KAAIrN,EAAcxX,OAAOoG,SAAS,SAIvC,MAAM,IAAI8K,YACR,kDACA,KAJFsG,EAAcvX,MAAQ0S,eAAe,QAASkS,EAM/C,CACF,CAGD,GAA0B,OAAtBrN,EAAcrX,IAAc,CAC9B1D,IAAI,EAAG,qDAGLimB,eAAehC,uBAGjB,MAAMlC,QAAesG,eACnBf,SAASvM,EAAcrX,KACvBD,GAOF,QAHEwiB,eAAelC,eAGVoE,EAAY,KAAMpG,EAC1B,CAGD,GAA4B,OAAxBhH,EAAcvX,OAA4C,OAA1BuX,EAActX,QAAkB,CAClEzD,IAAI,EAAG,sDAGLimB,eAAe/B,2BAGjB,MAAMnC,QAAeuG,mBACnBvN,EAAcvX,OAASuX,EAActX,QACrCA,GAOF,QAHEwiB,eAAejC,mBAGVmE,EAAY,KAAMpG,EAC1B,CAGD,OAAOoG,EACL,IAAI1T,YACF,gJACA,KAGL,CAAC,MAAO7T,GACP,OAAOunB,EAAYvnB,EACpB,CACH,CASO,SAAS2nB,wBACd,OAAOzjB,kBACT,CAUO,SAAS0jB,sBAAsBvpB,GACpC6F,mBAAqB7F,CACvB,CAkBAkY,eAAekR,eAAeI,EAAehlB,GAE3C,GAC2B,iBAAlBglB,IACNA,EAAc9d,QAAQ,SAAW,GAAK8d,EAAc9d,QAAQ,UAAY,GAYzE,OAVA3K,IAAI,EAAG,iCAGPyD,EAAQH,OAAOI,IAAM+kB,EAGrBhlB,EAAQH,OAAOG,QAAU,KACzBA,EAAQH,OAAOE,MAAQ,KAGhBklB,eAAejlB,GAEtB,MAAM,IAAIgR,YAAY,mCAAoC,IAE9D,CAkBA0C,eAAemR,mBAAmBG,EAAehlB,GAC/CzD,IAAI,EAAG,uCAGP,MAAMyW,EAAqBL,gBACzBqS,GACA,EACAhlB,EAAQoB,YAAYC,oBAItB,GACyB,OAAvB2R,GAC8B,iBAAvBA,IACNA,EAAmBhN,WAAW,OAC9BgN,EAAmB9M,SAAS,KAE7B,MAAM,IAAI8K,YACR,oPACA,KAYJ,OAPAhR,EAAQH,OAAOE,MAAQiT,EAGvBhT,EAAQH,OAAOG,QAAU,KACzBA,EAAQH,OAAOI,IAAM,KAGdglB,eAAejlB,EACxB,CAcA0T,eAAeuR,eAAejlB,GAE5B,MAAQH,OAAQyX,EAAelW,YAAamW,GAAuBvX,EAiCnE,OA9BAsX,EAAchX,OAAS4kB,WAAW5N,EAAchX,QAGhDgX,EAAcxd,KAAOqrB,SAAS7N,EAAcxd,KAAMwd,EAAcnX,SAGhEmX,EAAcnX,QAAUilB,YACtB9N,EAAcxd,KACdwd,EAAcnX,SAIhB5D,IACE,EACA,+BAA+Bgb,EAAmBlW,mBAAqB,UAAY,iBAIrFgkB,mBAAmB9N,GAGnB+N,sBAAsBhO,EAAeC,GAGrCgO,YAAYjO,GAGZkO,eAAe,CAAE3lB,OAAQyX,EAAelW,YAAamW,IAG9C2K,SAASliB,EAClB,CAaA,SAASklB,WAAW5kB,GAClB,IAEE,MAAMmlB,EAAc,GAAGnlB,EAAOolB,cAAc3O,QAAQ,QAAS,WAQ7D,MALoB,UAAhB0O,GACFA,EAAYC,cAIP,CAAC,QAAS,aAAc,WAAY,cAActgB,SACvDqgB,GAEEA,EACA,OACR,CAAI,MAEA,MAAO,OACR,CACH,CAaA,SAASL,YAAYtrB,EAAMqG,GAOzB,MAAO,GALU5G,gBAAgB4G,GAAW,SACzC/F,MAAM,KACNsD,WAGmB5D,GAAQ,OAChC,CAcA,SAASqrB,SAASrrB,EAAMqG,EAAU,MAEhC,MAAMwlB,EAAY,CAChB,YAAa,MACb,aAAc,OACd,kBAAmB,MACnB,gBAAiB,OAIbC,EAAUzsB,OAAOuM,OAAOigB,GAG9B,GAAIxlB,EAAS,CACX,MAAM0lB,EAAU1lB,EAAQ/F,MAAM,KAAK0rB,MAGnB,QAAZD,EACF/rB,EAAO,OACE8rB,EAAQxgB,SAASygB,IAAY/rB,IAAS+rB,IAC/C/rB,EAAO+rB,EAEV,CAGD,OAAOF,EAAU7rB,IAAS8rB,EAAQG,MAAMC,GAAMA,IAAMlsB,KAAS,KAC/D,CAmBA,SAASyrB,YAAYjO,GAEnB,MAAQqB,MAAOsN,EAAchO,UAAWiO,GACtCvT,gBAAgB2E,EAAcvX,SAAU,GAGlC4Y,MAAOwN,EAAoBlO,UAAWmO,GAC5CzT,gBAAgB2E,EAAcrW,iBAAkB,GAG1C0X,MAAO0N,EAAmBpO,UAAWqO,GAC3C3T,gBAAgB2E,EAAcpW,gBAAiB,EAG3CT,EACJ6W,EAAc7W,QACdylB,GAAkBK,cAClBN,GAAcxlB,QACd2lB,GAAwBG,cACxBJ,GAAoB1lB,QACpB6lB,GAAuBC,cACvBF,GAAmB5lB,QACnB6W,EAAc1W,eACd,IAGIF,EACJ4W,EAAc5W,OACdwlB,GAAkBM,aAClBP,GAAcvlB,OACd0lB,GAAwBI,aACxBL,GAAoBzlB,OACpB4lB,GAAuBE,aACvBH,GAAmB3lB,OACnB4W,EAAczW,cACd,IAMIF,EAAQpF,YACZI,KAAKqF,IACH,GACArF,KAAKoF,IACHuW,EAAc3W,OACZulB,GAAkBvlB,OAClBylB,GAAwBzlB,OACxB2lB,GAAuB3lB,OACvB2W,EAAcxW,cACd,EACF,IAGJ,GAIFwW,EAAc7W,OAASA,EACvB6W,EAAc5W,MAAQA,EACtB4W,EAAc3W,MAAQA,EAGtB,IAAK,IAAI8lB,IAAS,CAAC,SAAU,QAAS,SACA,iBAAzBnP,EAAcmP,KACvBnP,EAAcmP,IAAUnP,EAAcmP,GAAO1P,QAAQ,SAAU,IAGrE,CAgBA,SAASsO,mBAAmB9N,GAE1B,GAAIA,EAAmBlW,mBAAoB,CAEzC,IAEEkW,EAAmB9V,UAAYilB,iBAC7BnP,EAAmB9V,UACnB8V,EAAmBjW,oBACnB,EAEH,CAAC,MAAOnE,GACPZ,IAAI,EAAG,6CAGPgb,EAAmB9V,UAAY,IAChC,CAGD,IAEE8V,EAAmBhW,WAAaolB,kBAC9BpP,EAAmBhW,WACnBgW,EAAmBjW,oBAIrBiW,EAAmBhW,WAAakR,eAC9B,aACA8E,EAAmBhW,WAEtB,CAAC,MAAOpE,GACPD,aAAa,EAAGC,EAAO,8CAGvBoa,EAAmBhW,WAAa,IACjC,CAGD,IAEEgW,EAAmB/V,SAAWmlB,kBAC5BpP,EAAmB/V,SACnB+V,EAAmBjW,oBACnB,GAIFiW,EAAmB/V,SAAWiR,eAC5B,WACA8E,EAAmB/V,SAEtB,CAAC,MAAOrE,GACPD,aAAa,EAAGC,EAAO,4CAGvBoa,EAAmB/V,SAAW,IAC/B,CAGG,CAAC,UAAMxE,GAAWoI,SAASmS,EAAmBhW,aAChDhF,IAAI,EAAG,uDAIL,CAAC,UAAMS,GAAWoI,SAASmS,EAAmB/V,WAChDjF,IAAI,EAAG,qDAIL,CAAC,UAAMS,GAAWoI,SAASmS,EAAmB9V,YAChDlF,IAAI,EAAG,qDAEb,MAII,GACEgb,EAAmB/V,UACnB+V,EAAmB9V,WACnB8V,EAAmBhW,WAQnB,MALAgW,EAAmB/V,SAAW,KAC9B+V,EAAmB9V,UAAY,KAC/B8V,EAAmBhW,WAAa,KAG1B,IAAIyP,YACR,oGACA,IAIR,CAkBA,SAAS0V,iBACPjlB,EAAY,KACZH,EACAD,GAEA,IAAIulB,EAAmBnlB,EAGlBmlB,IACHnlB,EAAY,kBAId,MAAMolB,EAAe,CAAC,KAAM,MAAO,SAGnC,IAAIC,GAAmB,EAIrBxlB,GACqB,iBAAdG,GACPA,EAAUyE,SAAS,SAEnB0gB,EAAmBjU,gBACjB4C,GAAAA,aAAahc,gBAAgBkI,GAAY,SACzC,EACAJ,IAIFulB,EAAmBjU,gBAAgBlR,GAAW,EAAOJ,GAGjDulB,IAAqBtlB,UAChBslB,EAAiBnf,OAK5B,IAAK,MAAMsf,KAAYH,EAChBC,EAAazhB,SAAS2hB,GAEfD,IACVA,GAAmB,UAFZF,EAAiBG,GAO5B,OAAKD,GAKDF,EAAiBnf,QACnBmf,EAAiBnf,MAAQmf,EAAiBnf,MAAM5J,KAAKpD,GAASA,EAAKJ,WAC9DusB,EAAiBnf,OAASmf,EAAiBnf,MAAM7M,QAAU,WACvDgsB,EAAiBnf,OAK5Bmf,EAAmBnU,eAAe,YAAamU,GAGxCA,GAfE,IAgBX,CAcA,SAASD,kBAAkBplB,EAAYD,EAAoB0lB,GAAa,GACtE,GAAIzlB,GAAoC,iBAAfA,EAGvB,OAFAA,EAAaA,EAAWlH,QAET6L,SAAS,OAEf5E,EACHqlB,kBACEpR,GAAAA,aAAahc,gBAAgBgI,GAAa,QAC1CD,EACA0lB,GAEF,MAEHA,IACAzlB,EAAWyE,WAAW,eACrBzE,EAAWyE,WAAW,gBACtBzE,EAAWyE,WAAW,SACtBzE,EAAWyE,WAAW,UAGjB,IAAIzE,OAINA,EAAWwV,QAAQ,KAAM,GAEpC,CAkBA,SAASuO,sBAAsBhO,EAAeC,GAE5C,MAAMjW,mBAAEA,EAAkBD,mBAAEA,GAAuBkW,EAGnD,CAAC,gBAAiB,gBAAgB1G,SAASoW,IACzC,IAEM3P,EAAc2P,KAGd3lB,GACsC,iBAA/BgW,EAAc2P,IACrB3P,EAAc2P,GAAa/gB,SAAS,SAGpCoR,EAAc2P,GAAetU,gBAC3B4C,GAAAA,aAAahc,gBAAgB+d,EAAc2P,IAAe,SAC1D,EACA5lB,GAIFiW,EAAc2P,GAAetU,gBAC3B2E,EAAc2P,IACd,EACA5lB,GAKJiW,EAAc2P,GAAexU,eAC3BwU,EACA3P,EAAc2P,IAGnB,CAAC,MAAO9pB,GACPD,aACE,EACAC,EACA,iBAAiB8pB,yBAInB3P,EAAc2P,GAAe,IAC9B,KAIC,CAAC,UAAMjqB,GAAWoI,SAASkS,EAAcrW,gBAC3C1E,IAAI,EAAG,0DAIL,CAAC,UAAMS,GAAWoI,SAASkS,EAAcpW,eAC3C3E,IAAI,EAAG,wDAEX,CAcA,SAASipB,eAAef,GAEtB,MAGMyC,EAAYntB,OAAOotB,WAAWpU,KAAKO,UAAUmR,GAAe,SAYlE,GATAloB,IACE,EACA,gFACE2qB,EACC,SACDE,QAAQ,SAIRF,GAfc,UAgBhB,MAAM,IAAIlW,YACR,+DAGN,CCr/BA,MAAMqW,SAAW,GASV,SAASC,SAAS5L,GACvB2L,SAAS5pB,KAAKie,EAChB,CAQO,SAAS6L,iBACdhrB,IAAI,EAAG,2DACP,IAAK,MAAMmf,KAAM2L,SACfG,cAAc9L,GACd+L,aAAa/L,EAEjB,CCdA,SAASgM,mBAAmBvqB,EAAOwqB,EAAS1T,EAAU2T,GAUpD,OARA1qB,aAAa,EAAGC,GAGmB,gBAA/ByU,aAAajO,MAAMC,gBACdzG,EAAMK,MAIRoqB,EAAKzqB,EACd,CAYA,SAAS0qB,sBAAsB1qB,EAAOwqB,EAAS1T,EAAU2T,GAEvD,MAAMtqB,QAAEA,EAAOE,MAAEA,GAAUL,EAGrBgU,EAAahU,EAAMgU,YAAc,IAGvC8C,EAAS6T,OAAO3W,GAAY4W,KAAK,CAAE5W,aAAY7T,UAASE,SAC1D,CAOe,SAASwqB,gBAAgBC,GAEtCA,EAAIC,IAAIR,oBAGRO,EAAIC,IAAIL,sBACV,CC7Ce,SAASM,uBAAuBF,EAAKG,GAClD,IAEE,GAAIH,GAAOG,EAAoBtmB,OAAQ,CACrC,MAAMxE,EACJ,yEAGI+qB,EAAc,CAClB9lB,OAAQ6lB,EAAoB7lB,QAAU,EACtCD,YAAa8lB,EAAoB9lB,aAAe,GAChDE,MAAO4lB,EAAoB5lB,OAAS,EACpCC,WAAY2lB,EAAoB3lB,aAAc,EAC9CC,QAAS0lB,EAAoB1lB,SAAW,KACxCC,UAAWylB,EAAoBzlB,WAAa,MAI1C0lB,EAAY5lB,YACdwlB,EAAInmB,OAAO,eAIb,MAAMwmB,EAAUC,UAAU,CAExBC,SAA+B,GAArBH,EAAY9lB,OAAc,IAEpCkmB,MAAOJ,EAAY/lB,YAEnBomB,QAASL,EAAY7lB,MACrBmmB,QAAS,CAAChB,EAAS1T,KACjBA,EAAS2U,OAAO,CACdb,KAAM,KACJ9T,EAAS6T,OAAO,KAAKe,KAAK,CAAEvrB,WAAU,EAExCwrB,QAAS,KACP7U,EAAS6T,OAAO,KAAKe,KAAKvrB,EAAQ,GAEpC,EAEJyrB,KAAOpB,GAGqB,OAAxBU,EAAY3lB,SACc,OAA1B2lB,EAAY1lB,WACZglB,EAAQqB,MAAM9vB,MAAQmvB,EAAY3lB,SAClCilB,EAAQqB,MAAMC,eAAiBZ,EAAY1lB,YAE3CpG,IAAI,EAAG,2CACA,KAOb0rB,EAAIC,IAAII,GAER/rB,IACE,EACA,8CAA8C8rB,EAAY/lB,4BAA4B+lB,EAAY9lB,8CAA8C8lB,EAAY5lB,cAE/J,CACF,CAAC,MAAOtF,GACP,MAAM,IAAI6T,YACR,yEACA,KACAK,SAASlU,EACZ,CACH,CCxDA,SAAS+rB,sBAAsBvB,EAAS1T,EAAU2T,GAChD,IAEE,MAAMuB,EAAcxB,EAAQyB,QAAQ,iBAAmB,GAGvD,IACGD,EAAY/jB,SAAS,sBACrB+jB,EAAY/jB,SAAS,uCACrB+jB,EAAY/jB,SAAS,uBAEtB,MAAM,IAAI4L,YACR,iHACA,KAKJ,OAAO4W,GACR,CAAC,MAAOzqB,GACP,OAAOyqB,EAAKzqB,EACb,CACH,CAmBA,SAASksB,sBAAsB1B,EAAS1T,EAAU2T,GAChD,IAEE,MAAMpM,EAAOmM,EAAQnM,KAGftS,EAAYC,KAAAA,KAGlB,IAAKqS,GAAQ9gB,cAAc8gB,GAQzB,MAPAjf,IACE,EACA,yBAAyB2M,yBACvBye,EAAQyB,QAAQ,oBAAsBzB,EAAQ2B,WAAWC,2DAIvD,IAAIvY,YACR,yBAAyB9H,8JACzB,KAKJ,MAAM7H,EAAqByjB,wBAGrB/kB,EAAQ4S,gBAEZ6I,EAAKzb,OAASyb,EAAKxb,SAAWwb,EAAK1b,QAAU0b,EAAK9K,MAElD,EAEArP,GAIF,GAAc,OAAVtB,IAAmByb,EAAKvb,IAQ1B,MAPA1D,IACE,EACA,yBAAyB2M,yBACvBye,EAAQyB,QAAQ,oBAAsBzB,EAAQ2B,WAAWC,2FACmBxW,KAAKO,UAAUkI,OAGzF,IAAIxK,YACR,yBAAyB9H,yQACzB,KAKJ,GAAIsS,EAAKvb,KAAOpF,uBAAuB2gB,EAAKvb,KAC1C,MAAM,IAAI+Q,YACR,yBAAyB9H,oLACzB,KA0CJ,OArCAye,EAAQ6B,iBAAmB,CAEzBtgB,YACArJ,OAAQ,CACNE,QACAE,IAAKub,EAAKvb,IACVE,QACEqb,EAAKrb,SACL,GAAGwnB,EAAQniB,OAAOikB,UAAY,WAAWjO,EAAK1hB,MAAQ,QACxDA,KAAM0hB,EAAK1hB,KACXwG,OAAQkb,EAAKlb,OACbC,IAAKib,EAAKjb,IACVC,WAAYgb,EAAKhb,WACjBC,OAAQ+a,EAAK/a,OACbC,MAAO8a,EAAK9a,MACZC,MAAO6a,EAAK7a,MACZM,cAAe0R,gBACb6I,EAAKva,eACL,EACAI,GAEFH,aAAcyR,gBACZ6I,EAAKta,cACL,EACAG,IAGJD,YAAa,CACXC,qBACAC,oBAAoB,EACpBC,WAAYia,EAAKja,WACjBC,SAAUga,EAAKha,SACfC,UAAWkR,gBAAgB6I,EAAK/Z,WAAW,EAAMJ,KAK9CumB,GACR,CAAC,MAAOzqB,GACP,OAAOyqB,EAAKzqB,EACb,CACH,CAOe,SAASusB,qBAAqBzB,GAE3CA,EAAI0B,KAAK,CAAC,IAAK,cAAeT,uBAG9BjB,EAAI0B,KAAK,CAAC,IAAK,cAAeN,sBAChC,CC7KA,MAAMO,aAAe,CACnBC,IAAK,YACLC,KAAM,aACNC,IAAK,YACL9J,IAAK,kBACLhgB,IAAK,iBAgBPyT,eAAesW,cAAcrC,EAAS1T,EAAU2T,GAC9C,IAEE,MAAMqC,EAAiBhvB,cAGvB,IAAIivB,GAAoB,EACxBvC,EAAQwC,OAAOhW,GAAG,SAAUiW,IACtBA,IACFF,GAAoB,EACrB,IAIH,MAAMlqB,EAAU2nB,EAAQ6B,iBAGlBtgB,EAAYlJ,EAAQkJ,UAG1B3M,IAAI,EAAG,qBAAqB2M,4CAGtBgb,YAAYlkB,GAAS,CAAC7C,EAAOuT,KAKjC,GAHAiX,EAAQwC,OAAOvG,mBAAmB,SAG9BsG,EACF3tB,IACE,EACA,qBAAqB2M,mFAHzB,CASA,GAAI/L,EACF,MAAMA,EAIR,IAAKuT,IAASA,EAAK4N,OASjB,MARA/hB,IACE,EACA,qBAAqB2M,qBACnBye,EAAQyB,QAAQ,oBAChBzB,EAAQ2B,WAAWC,mDACiB7Y,EAAK4N,WAGvC,IAAItN,YACR,qBAAqB9H,yGACrB,KAKJ,GAAIwH,EAAK4N,OAAQ,CACf/hB,IACE,EACA,qBAAqB2M,yCAAiD+gB,UAIxE,MAAMnwB,KAAEA,EAAIyG,IAAEA,EAAGC,WAAEA,EAAUL,QAAEA,GAAYuQ,EAAK1Q,QAAQH,OAGxD,OAAIU,EACK0T,EAAS4U,KAAKjvB,UAAU8W,EAAK4N,OAAQxkB,KAI9Cma,EAASoW,OAAO,eAAgBT,aAAa9vB,IAAS,aAGjD0G,GACHyT,EAASqW,WAAWnqB,GAIN,QAATrG,EACHma,EAAS4U,KAAKnY,EAAK4N,QACnBrK,EAAS4U,KAAK9uB,OAAOC,KAAK0W,EAAK4N,OAAQ,WAC5C,CAlDA,CAkDA,GAEJ,CAAC,MAAOnhB,GACP,OAAOyqB,EAAKzqB,EACb,CACH,CASe,SAASotB,aAAatC,GAKnCA,EAAI0B,KAAK,IAAKK,eAMd/B,EAAI0B,KAAK,aAAcK,cACzB,CCpIA,MAAMQ,gBAAkB,IAAIrwB,KAGtBswB,YAAc1X,KAAKpD,MACvB4F,GAAAA,aAAaxX,KAAAA,KAAK/F,YAAW,gBAAiB,SAI1C0yB,aAAe,GAGfC,eAAiB,IAGjBC,WAAa,GAUnB,SAASC,0BACP,OAAOH,aAAapY,QAAO,CAACwY,EAAGC,IAAMD,EAAIC,GAAG,GAAKL,aAAa9vB,MAChE,CAUA,SAASowB,oBACP,OAAOC,aAAY,KACjB,MAAMC,EAAQ1I,eACR2I,EACuB,IAA3BD,EAAM/K,iBACF,EACC+K,EAAM9K,iBAAmB8K,EAAM/K,iBAAoB,IAE1DuK,aAAajtB,KAAK0tB,GACdT,aAAa9vB,OAASgwB,YACxBF,aAAahtB,OACd,GACAitB,eACL,CASe,SAASS,aAAanD,GAGnCX,SAAS0D,qBAKT/C,EAAItU,IAAI,WAAW,CAACgU,EAAS1T,EAAU2T,KACrC,IACErrB,IAAI,EAAG,qCAEP,MAAM2uB,EAAQ1I,eACR6I,EAASX,aAAa9vB,OACtB0wB,EAAgBT,0BAGtB5W,EAAS4U,KAAK,CAEZf,OAAQ,KACRyD,SAAUf,gBACVgB,OAAQ,GAAG7vB,KAAK8vB,OAAOnxB,iBAAmBkwB,gBAAgBjwB,WAAa,IAAO,cAG9EmxB,cAAejB,YAAYrrB,QAC3BusB,kBAAmB5V,eAGnB6V,kBAAmBV,EAAMvK,iBACzBkL,iBAAkBX,EAAM/K,iBACxB2L,iBAAkBZ,EAAM9K,iBACxB2L,cAAeb,EAAM7K,eACrB2L,YAAcd,EAAM9K,iBAAmB8K,EAAM/K,iBAAoB,IAGjEpd,KAAM0f,kBAGN4I,SACAC,gBACAhuB,QACEkJ,MAAM8kB,KAAmBZ,aAAa9vB,OAClC,oEACA,QAAQywB,mCAAwCC,EAAclE,QAAQ,OAG5E6E,WAAYf,EAAM5K,eAClB4L,YAAahB,EAAM3K,mBACnB4L,mBAAoBjB,EAAM1K,uBAC1B4L,oBAAqBlB,EAAMzK,4BAE9B,CAAC,MAAOtjB,GACP,OAAOyqB,EAAKzqB,EACb,IAEL,CC9Ge,SAASkvB,SAASpE,GAE3BrW,aAAanO,GAAG3B,QAIlBmmB,EAAItU,IAAI/B,aAAanO,GAAGC,OAAS,KAAK,CAACikB,EAAS1T,EAAU2T,KACxD,IACErrB,IAAI,EAAG,qCAEP0X,EAASqY,SAASvuB,KAAIA,KAAC/F,YAAW,SAAU,cAAe,CACzDu0B,cAAc,GAEjB,CAAC,MAAOpvB,GACP,OAAOyqB,EAAKzqB,EACb,IAGP,CClBe,SAASqvB,oBAAoBvE,GAK1CA,EAAI0B,KAAK,+BAA+BjW,MAAOiU,EAAS1T,EAAU2T,KAChE,IACErrB,IAAI,EAAG,0CAGP,MAAM0K,EAAayI,KAAKhF,uBAGxB,IAAKzD,IAAeA,EAAWrM,OAC7B,MAAM,IAAIoW,YACR,mHACA,KAKJ,MAAMyb,EAAQ9E,EAAQhU,IAAI,WAG1B,IAAK8Y,GAASA,IAAUxlB,EACtB,MAAM,IAAI+J,YACR,2EACA,KAKJ,MAAMiF,EAAa0R,EAAQniB,OAAOyQ,WAGlC,IAAIA,EAkBF,MAAM,IAAIjF,YAAY,qCAAsC,KAjB5D,UACQgF,gBAAgBC,EACvB,CAAC,MAAO9Y,GACP,MAAM,IAAI6T,YACR,6BAA6B7T,EAAMG,UACnC,KACA+T,SAASlU,EACZ,CAGD8W,EAAS6T,OAAO,KAAKe,KAAK,CACxB1X,WAAY,IACZwa,kBAAmB5V,eACnBzY,QAAS,+CAA+C2Y,MAM7D,CAAC,MAAO9Y,GACP,OAAOyqB,EAAKzqB,EACb,IAEL,CC3CA,MAAMuvB,cAAgB,IAAIC,IAGpB1E,IAAM2E,UAsBLlZ,eAAemZ,YAAYC,GAChC,IAEE,MAAM9sB,EAAU8R,cAAc,CAC5BjQ,OAAQirB,IAOV,KAHAA,EAAgB9sB,EAAQ6B,QAGLC,SAAWmmB,IAC5B,MAAM,IAAIjX,YACR,mFACA,KAMJ,MAAM+b,EAA+C,KAA5BD,EAAc7qB,YAAqB,KAGtD+qB,EAAUC,OAAOC,gBAGjBC,EAASF,OAAO,CACpBD,UACAI,OAAQ,CACNC,UAAWN,KA2Cf,GAtCA9E,IAAIqF,QAAQ,gBAGZrF,IAAIC,IACFqF,KAAK,CACHC,QAAS,CAAC,OAAQ,MAAO,cAM7BvF,IAAIC,KAAI,CAACP,EAAS1T,EAAU2T,KAC1B3T,EAASwZ,IAAI,gBAAiB,QAC9B7F,GAAM,IAIRK,IAAIC,IACF0E,QAAQ7E,KAAK,CACXU,MAAOsE,KAKX9E,IAAIC,IACF0E,QAAQc,WAAW,CACjBC,UAAU,EACVlF,MAAOsE,KAKX9E,IAAIC,IAAIiF,EAAOS,QAGf3F,IAAIC,IAAI0E,QAAQiB,OAAO9vB,KAAIA,KAAC/F,YAAW,aAGlC80B,EAAclqB,IAAIC,MAAO,CAE5B,MAAMirB,EAAavZ,KAAKwZ,aAAa9F,KAGrC+F,2BAA2BF,GAG3BA,EAAWG,OAAOnB,EAAc9qB,KAAM8qB,EAAc/qB,MAAM,KAExD2qB,cAAce,IAAIX,EAAc9qB,KAAM8rB,GAEtCvxB,IACE,EACA,mCAAmCuwB,EAAc/qB,QAAQ+qB,EAAc9qB,QACxE,GAEJ,CAGD,GAAI8qB,EAAclqB,IAAId,OAAQ,CAE5B,IAAI5I,EAAKg1B,EAET,IAEEh1B,EAAMqc,GAAYA,aAChBxX,KAAIA,KAACxE,gBAAgBuzB,EAAclqB,IAAIE,UAAW,cAClD,QAIForB,EAAO3Y,GAAYA,aACjBxX,KAAIA,KAACxE,gBAAgBuzB,EAAclqB,IAAIE,UAAW,cAClD,OAEH,CAAC,MAAO3F,GACPZ,IACE,EACA,qDAAqDuwB,EAAclqB,IAAIE,sDAE1E,CAED,GAAI5J,GAAOg1B,EAAM,CAEf,MAAMC,EAAc7Z,MAAMyZ,aAAa,CAAE70B,MAAKg1B,QAAQjG,KAGtD+F,2BAA2BG,GAG3BA,EAAYF,OAAOnB,EAAclqB,IAAIZ,KAAM8qB,EAAc/qB,MAAM,KAE7D2qB,cAAce,IAAIX,EAAclqB,IAAIZ,KAAMmsB,GAE1C5xB,IACE,EACA,oCAAoCuwB,EAAc/qB,QAAQ+qB,EAAclqB,IAAIZ,QAC7E,GAEJ,CACF,CAGDmmB,uBAAuBF,IAAK6E,EAAczqB,cAG1CqnB,qBAAqBzB,KAGrBsC,aAAatC,KACbmD,aAAanD,KACboE,SAASpE,KACTuE,oBAAoBvE,KAGpBD,gBAAgBC,IACjB,CAAC,MAAO9qB,GACP,MAAM,IAAI6T,YACR,qDACA,KACAK,SAASlU,EACZ,CACH,CAOO,SAASixB,eAEd,GAAI1B,cAAc/O,KAAO,EAAG,CAC1BphB,IAAI,EAAG,iCAGP,IAAK,MAAOyF,EAAMH,KAAW6qB,cAC3B7qB,EAAO8Y,OAAM,KACX+R,cAAc2B,OAAOrsB,GACrBzF,IAAI,EAAG,mCAAmCyF,KAAQ,GAGvD,CACH,CASO,SAASssB,aACd,OAAO5B,aACT,CASO,SAAS6B,aACd,OAAO3B,OACT,CASO,SAAS4B,SACd,OAAOvG,GACT,CAYO,SAAS/f,mBAAmBkgB,GAEjC,MAAMpoB,EAAU8R,cAAc,CAC5BjQ,OAAQ,CACNQ,aAAc+lB,KAKlBD,uBAAuBF,IAAKjoB,EAAQ6B,OAAOumB,oBAC7C,CAUO,SAASF,IAAI1uB,KAASi1B,GAC3BxG,IAAIC,IAAI1uB,KAASi1B,EACnB,CAUO,SAAS9a,IAAIna,KAASi1B,GAC3BxG,IAAItU,IAAIna,KAASi1B,EACnB,CAUO,SAAS9E,KAAKnwB,KAASi1B,GAC5BxG,IAAI0B,KAAKnwB,KAASi1B,EACpB,CASA,SAAST,2BAA2BnsB,GAClCA,EAAOsS,GAAG,eAAe,CAAChX,EAAOgtB,KAC/BjtB,aACE,EACAC,EACA,0BAA0BA,EAAMG,+BAElC6sB,EAAOpN,SAAS,IAGlBlb,EAAOsS,GAAG,SAAUhX,IAClBD,aAAa,EAAGC,EAAO,0BAA0BA,EAAMG,UAAU,IAGnEuE,EAAOsS,GAAG,cAAegW,IACvBA,EAAOhW,GAAG,SAAUhX,IAClBD,aAAa,EAAGC,EAAO,0BAA0BA,EAAMG,UAAU,GACjE,GAEN,CAEA,IAAeuE,OAAA,CACbgrB,wBACAuB,0BACAE,sBACAC,sBACAC,cACAtmB,sCACAggB,QACAvU,QACAgW,WCvVKjW,eAAegb,gBAAgBC,EAAW,SAEzC7a,QAAQyQ,WAAW,CAEvBgD,iBAGA6G,eAGAtM,aAIF3mB,QAAQyzB,KAAKD,EACf,CCkBOjb,eAAemb,WAAWC,GAE/B,MAAM9uB,EAAU8R,cAAcgd,GAG9B/J,sBAAsB/kB,EAAQoB,YAAYC,oBAG1CrD,YAAYgC,EAAQjE,SAGhBiE,EAAQ2D,MAAME,sBAChBkrB,oCAIIna,WAAW5U,EAAQb,WAAYa,EAAQ6B,OAAOM,aAG9Cye,SAAS5gB,EAAQ+C,KAAM/C,EAAQpB,UAAUpC,KACjD,CASA,SAASuyB,8BACPxyB,IAAI,EAAG,sDAGPpB,QAAQgZ,GAAG,QAAShE,IAClB5T,IAAI,EAAG,uCAAuC4T,KAAQ,IAIxDhV,QAAQgZ,GAAG,UAAUT,MAAOpC,EAAMnB,KAChC5T,IAAI,EAAG,iBAAiB+U,sBAAyBnB,YAC3Cue,iBAAiB,IAIzBvzB,QAAQgZ,GAAG,WAAWT,MAAOpC,EAAMnB,KACjC5T,IAAI,EAAG,iBAAiB+U,sBAAyBnB,YAC3Cue,iBAAiB,IAIzBvzB,QAAQgZ,GAAG,UAAUT,MAAOpC,EAAMnB,KAChC5T,IAAI,EAAG,iBAAiB+U,sBAAyBnB,YAC3Cue,iBAAiB,IAIzBvzB,QAAQgZ,GAAG,qBAAqBT,MAAOvW,EAAOmU,KAC5CpU,aAAa,EAAGC,EAAO,iBAAiBmU,kBAClCod,gBAAgB,EAAE,GAE5B,CAEA,IAAe5d,MAAA,IAEVjP,OAGH+P,sBACAE,4BACAI,gCAGAO,8BACAR,gCAGA4c,sBACA5K,0BACAE,wBACAD,wBAGApC,kBACA4M,gCAGAnyB,QACAW,0BACAS,0BACAS,YAAa,SAAUzB,GASrByB,YAPgB0T,cAAc,CAC5B/V,QAAS,CACPY,WAKgBZ,QAAQY,MAC7B,EACD0B,qBAAsB,SAAUrC,GAS9BqC,qBAPgByT,cAAc,CAC5B/V,QAAS,CACPC,eAKyBD,QAAQC,UACtC,EACDsC,kBAAmB,SAAUJ,EAAMC,EAAMlC,GAEvC,MAAM+D,EAAU8R,cAAc,CAC5B/V,QAAS,CACPmC,OACAC,OACAlC,YAKJqC,kBACE0B,EAAQjE,QAAQmC,KAChB8B,EAAQjE,QAAQoC,KAChB6B,EAAQjE,QAAQE,OAEnB"} +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("colors");var fs=require("fs"),path=require("path"),httpsProxyAgent=require("https-proxy-agent"),url=require("url"),dotenv=require("dotenv"),zod=require("zod"),http=require("http"),https=require("https"),tarn=require("tarn"),uuid=require("uuid"),puppeteer=require("puppeteer"),DOMPurify=require("dompurify"),jsdom=require("jsdom"),cors=require("cors"),express=require("express"),multer=require("multer"),rateLimit=require("express-rate-limit"),_documentCurrentScript="undefined"!=typeof document?document.currentScript:null;const __dirname$1=url.fileURLToPath(new URL("../.","undefined"==typeof document?require("url").pathToFileURL(__filename).href:_documentCurrentScript&&"SCRIPT"===_documentCurrentScript.tagName.toUpperCase()&&_documentCurrentScript.src||new URL("index.cjs",document.baseURI).href));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function getAbsolutePath(e){return path.isAbsolute(e)?path.normalize(e):path.resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:n}=logging;if(5!==t&&(0===t||t>n||n>r.length))return;const i=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,i),logging.toConsole&&console.log.apply(void 0,[i.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:n,levelsDesc:i}=logging;if(0===e||e>n||n>i.length)return;const s=`${getNewDate()} [${i[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:n,toFile:i}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(n),enableFileLogging(o,r,i)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"log",logging.file=t||"highcharts-export-server.log")}function _logToFile(e,t){logging.pathCreated||(!fs.existsSync(getAbsolutePath(logging.dest))&&fs.mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(path.join(logging.dest,logging.file)),logging.pathCreated=!0),fs.appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}};dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;zod.z.setErrorMap(_customErrorMap);const v={boolean:e=>e?zod.z.boolean():zod.z.union([zod.z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),zod.z.boolean()]).nullable(),string:e=>e?zod.z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):zod.z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?zod.z.enum([...e]):zod.z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=zod.z.string().trim().array(),n=zod.z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),i=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(i):zod.z.union([n,r]).transform(i).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?zod.z.number().positive():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().positive()]).nullable(),nonNegativeNum:e=>e?zod.z.number().nonnegative():zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):zod.z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>zod.z.union([zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable(),additionalOptions:()=>zod.z.union([zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),zod.z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):zod.z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>zod.z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():zod.z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?zod.z.number().gte(.1).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=zod.z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=zod.z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?zod.z.union([t,o]).nullable():zod.z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?zod.z.number().int().gte(0).lte(5):zod.z.union([zod.z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),zod.z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>zod.z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>zod.z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>zod.z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>zod.z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>zod.z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>zod.z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>zod.z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>zod.z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>zod.z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>zod.z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>zod.z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>zod.z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>zod.z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>zod.z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=zod.z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=zod.z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===zod.z.ZodIssueCode.invalid_type)return e.received===zod.z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===zod.z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===zod.z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig),nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1,o=!0){return _mergeOptions(getOptions(t),validateOptions(e,o))}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,n)=>t[o]=e.length-1===n?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty object.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const n=e[r];void 0===n.value?_createNestedProps(n,t,`${o}.${r}`):(t[n.cliName||r]=`${o}.${r}`.substring(1),void 0!==n.legacyName&&(t[n.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}async function get$1(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkCache(e,t){try{let o;const r=getCachePath(),n=path.join(r,"manifest.json"),i=path.join(r,"sources.js");if(!fs.existsSync(r)&&fs.mkdirSync(r,{recursive:!0}),!fs.existsSync(n)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,i);else{let r=!1;const s=JSON.parse(fs.readFileSync(n),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,i):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=fs.readFileSync(i,"utf8"),o=s.modules,cache.hcVersion=_extractHcVersion(cache.sources))}await _saveConfigToManifest(e.version,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHcVersion(){return cache.hcVersion}async function updateHcVersion(e){const t=updateOptions({highcharts:{version:e}});await checkCache(t.highcharts,t.server.proxy)}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _saveConfigToManifest(e,t={}){cache.activeManifest={version:e,modules:t},log(3,"[cache] Writing a new manifest.");try{fs.writeFileSync(path.join(getCachePath(),"manifest.json"),JSON.stringify(cache.activeManifest),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _updateCache(e,t,o){try{const r="latest"===e.version?null:`${e.version}`;log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`);const n=e.cdnUrl||cache.cdnUrl,i=_configureRequest(t),s={};return cache.sources=(await Promise.all([...e.coreScripts.map((e=>_fetchScript(r?`${n}/${r}/${e}`:`${n}/${e}`,i,s,!0))),...e.moduleScripts.map((e=>_fetchScript("map"===e?r?`${n}/maps/${r}/modules/${e}`:`${n}/maps/modules/${e}`:r?`${n}/${r}/modules/${e}`:`${n}/modules/${e}`,i,s))),...e.indicatorScripts.map((e=>_fetchScript(r?`${n}/stock/${r}/indicators/${e}`:`${n}/stock/indicators/${e}`,i,s))),...e.customScripts.map((e=>_fetchScript(`${e}`,i)))])).join(";\n"),cache.hcVersion=_extractHcVersion(cache.sources),fs.writeFileSync(o,cache.sources),s}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}async function _fetchScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const n=await get$1(`${e}.js`,t);if(200===n.statusCode&&"string"==typeof n.text){if(o){o[_extractModuleName(e)]=1}return n.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${n.statusCode}).`,404).setError(n);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}function _configureRequest(e){const t=e.host,o=e.port;if(t&&o)try{return{agent:new httpsProxyAgent.HttpsProxyAgent({host:t,port:o}),timeout:e.timeout}}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}return{}}function _extractHcVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function _extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:n,wrap:i}=Highcharts;Highcharts.setOptionsObj=n(!1,{},o()),window.isRenderComplete=!1,i(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=n(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),i(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=n(!1,l,a,s),p=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a);const u=new Function(`return ${e.globalOptions}`)();u&&r(u),Highcharts[e.constr]("container",c,p);const d=Array.from(document.querySelectorAll(".highcharts-container image"));await Promise.race([Promise.all(d.map((e=>e.complete&&0!==e.naturalHeight?Promise.resolve():new Promise((t=>e.addEventListener("load",t,{once:!0})))))),new Promise((e=>setTimeout(e,2e3)))]);const g=o();for(const e in g)"function"!=typeof g[e]&&delete g[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const pageTemplate=fs.readFileSync(path.join(__dirname$1,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...n}=t,i={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&n};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to launch and get a browser instance (try ${++e}).`),browser=await puppeteer.launch(i)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===i.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const n=[];if(r.js&&n.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");n.push(t?{content:fs.readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of n)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}n.length=0;const i=[];if(r.css){const n=r.css.match(/@import\s*([^;]*);/g);if(n)for(let e of n)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?i.push({url:e}):t.allowFileResources&&i.push({path:getAbsolutePath(e)}));i.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of i)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}i.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(pageTemplate,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:path.join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let n=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;n=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const i=await _getChartSize(e,n,t.scale),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(i.chartHeight||t.height)),c=Math.abs(Math.ceil(i.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:n?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:n}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(n>1?n:500)}}))}async function _getChartSize(e,t,o){return t?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(o)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new tarn.Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&_getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),n=await puppeteerExport(t.page,e.export,e.customLogic);if(n instanceof Error)throw"Rasterization timeout"===n.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===n.name||"Rasterization timeout"===n.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(n):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${r()}ms.`).setError(n);return e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t),poolStats.timeSpent+=r(),poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${r()}ms.`),{result:n,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function _getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:n,pendingAcquires:i,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${n}.`),log(5,`[pool] The number of resources waiting to be acquired: ${i}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:uuid.v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new jsdom.JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r||`chart.${n}`,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:n}=t.options.export;try{o?fs.writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,n)):fs.writeFileSync(r,"svg"!==n?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=fs.readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.options=null,t.export.instr=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.options=null,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.constr=_fixConstr(t.constr),t.type=_fixType(t.type,t.outfile),t.outfile=_fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o),_handleGlobalAndTheme(t,o),_handleSize(t),_checkDataSize({export:t,customLogic:o}),postWork(e)}function _fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function _fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e||"png"}`}function _fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function _handleSize(e){const{chart:t,exporting:o}=isAllowedConfig(e.instr)||!1,{chart:r,exporting:n}=isAllowedConfig(e.globalOptions)||!1,{chart:i,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=e.height||o?.sourceHeight||t?.height||n?.sourceHeight||r?.height||s?.sourceHeight||i?.height||e.defaultHeight||400,l=e.width||o?.sourceWidth||t?.width||n?.sourceWidth||r?.width||s?.sourceWidth||i?.width||e.defaultWidth||600,c=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||n?.scale||s?.scale||e.defaultScale||1,5)),2);e.height=a,e.width=l,e.scale=c;for(let t of["height","width","scale"])"string"==typeof e[t]&&(e[t]=+e[t].replace(/px|%/gi,""))}function _handleCustomLogic(e){if(e.allowCodeExecution){try{e.resources=_handleResources(e.resources,e.allowFileResources,!0),e.resources=validateOption("resources",e.resources)}catch(t){log(2,"[chart] The `resources` cannot be loaded."),e.resources=null}try{e.customCode=_handleCustomCode(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=_handleCustomCode(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){let r=e;r||(e="resources.json");const n=["js","css","files"];let i=!1;t&&"string"==typeof e&&e.endsWith(".json")?r=isAllowedConfig(fs.readFileSync(getAbsolutePath(e),"utf8"),!1,o):(r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files);for(const e in r)n.includes(e)?i||(i=!0):delete r[e];return i?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r):null}function _handleCustomCode(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?_handleCustomCode(fs.readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}function _handleGlobalAndTheme(e,t){const{allowFileResources:o,allowCodeExecution:r}=t;["globalOptions","themeOptions"].forEach((t=>{try{e[t]&&(o&&"string"==typeof e[t]&&e[t].endsWith(".json")?e[t]=isAllowedConfig(fs.readFileSync(getAbsolutePath(e[t]),"utf8"),!0,r):e[t]=isAllowedConfig(e[t],!0,r),e[t]=validateOption(t,e[t]))}catch(o){logWithStack(2,o,`[chart] The \`${t}\` cannot be loaded.`),e[t]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}function _checkDataSize(e){const t=Buffer.byteLength(JSON.stringify(e),"utf-8");if(log(3,`[chart] The current total size of the data for the export process is around ${(t/1048576).toFixed(2)}MB.`),t>=104857600)throw new ExportError("[chart] The data for the export process exceeds 100MB limit.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:n,stack:i}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:n,stack:i})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const n=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(n),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=uuid.v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const n=getAllowCodeExecution(),i=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,n);if(null===i&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`[validation] Request [${r}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`[validation] Request [${r}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions={requestId:r,export:{instr:i,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,n),themeOptions:isAllowedConfig(t.themeOptions,!0,n)},customLogic:{allowCodeExecution:n,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,n)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const n=e.validatedOptions,i=n.requestId;log(4,`[export] Request [${i}] - Got an incoming HTTP request.`),await startExport(n,((n,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${i}] - The client closed the connection before the chart finished processing.`);else{if(n)throw n;if(!s||!s.result)throw log(2,`[export] Request [${i}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${i}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${i}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:n,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),n||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(fs.readFileSync(path.join(__dirname$1,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHcVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){getOptions().ui.enable&&e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(path.join(__dirname$1,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const n=e.params.newVersion;if(!n)throw new ExportError("[version] No new version supplied.",400);try{await updateHcVersion(n)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHcVersion(),message:`Successfully updated Highcharts to version: ${n}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e={}){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),n=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(n.none()),app.use(express.static(path.join(__dirname$1,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=fs.readFileSync(path.join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code: ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};exports.default=index,exports.initExport=initExport; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n  return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n  // If the `objArr` is null or not of the `object` type, return it\r\n  if (objArr === null || typeof objArr !== 'object') {\r\n    return objArr;\r\n  }\r\n\r\n  // Prepare either a new array or a new object\r\n  const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n  // Recursively copy each property\r\n  for (const key in objArr) {\r\n    if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n      objArrCopy[key] = deepCopy(objArr[key]);\r\n    }\r\n  }\r\n\r\n  // Return the copied object\r\n  return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n  try {\r\n    // Try to call the function\r\n    return await fn(...args);\r\n  } catch (error) {\r\n    // Calculate delay in ms\r\n    const delayInMs = 2 ** attempt * 1000;\r\n\r\n    // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n    if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n      throw error;\r\n    }\r\n\r\n    // Wait given amount of time\r\n    await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n    /// TO DO: Correct\r\n    // // Information about the resource timeout\r\n    // log(\r\n    //   3,\r\n    //   `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n    // );\r\n\r\n    // Try again\r\n    return expBackoff(fn, attempt, ...args);\r\n  }\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function getAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n  return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n  // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n  if (type === 'pdf' || type == 'svg') {\r\n    return Buffer.from(input, 'utf8').toString('base64');\r\n  }\r\n\r\n  // For png and jpeg input is already a Base64 string\r\n  return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n  // Get rid of the GMT text information\r\n  return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n  return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an object, `false`\r\n * otherwise.\r\n */\r\nexport function isObject(item) {\r\n  return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an empty object, `false`\r\n * otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n  return (\r\n    typeof item === 'object' &&\r\n    !Array.isArray(item) &&\r\n    item !== null &&\r\n    Object.keys(item).length === 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} Returns `true` if a private IP range URL is found, `false`\r\n * otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n  const regexPatterns = [\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n    /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n  ];\r\n\r\n  return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n  const start = process.hrtime.bigint();\r\n  return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n  const multiplier = Math.pow(10, precision || 0);\r\n  return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n  return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n    ? false\r\n    : !!item;\r\n}\r\n\r\nexport default {\r\n  __dirname,\r\n  clearText,\r\n  deepCopy,\r\n  expBackoff,\r\n  getAbsolutePath,\r\n  getBase64,\r\n  getNewDate,\r\n  getNewDateTime,\r\n  isObject,\r\n  isObjectEmpty,\r\n  isPrivateRangeUrlFound,\r\n  measureTime,\r\n  roundNumber,\r\n  toBoolean\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n  // Flags for logging status\r\n  toConsole: true,\r\n  toFile: false,\r\n  pathCreated: false,\r\n  // Full path to the log file\r\n  pathToLog: '',\r\n  // Log levels\r\n  levelsDesc: [\r\n    {\r\n      title: 'error',\r\n      color: colors[0]\r\n    },\r\n    {\r\n      title: 'warning',\r\n      color: colors[1]\r\n    },\r\n    {\r\n      title: 'notice',\r\n      color: colors[2]\r\n    },\r\n    {\r\n      title: 'verbose',\r\n      color: colors[3]\r\n    },\r\n    {\r\n      title: 'benchmark',\r\n      color: colors[4]\r\n    }\r\n  ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n  const [newLevel, ...texts] = args;\r\n\r\n  // Current logging options\r\n  const { levelsDesc, level } = logging;\r\n\r\n  // Check if the log level is within a correct range or is it a benchmark log\r\n  if (\r\n    newLevel !== 5 &&\r\n    (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n  ) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n  // Get the main message\r\n  const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n  // Current logging options\r\n  const { level, levelsDesc } = logging;\r\n\r\n  // Check if the log level is within a correct range\r\n  if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n    return;\r\n  }\r\n\r\n  // Create a message's prefix\r\n  const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n  // Add the whole stack message\r\n  const stackMessage = error && error.stack;\r\n\r\n  // Combine custom message or error message with error stack message, if exists\r\n  const texts = [mainMessage];\r\n  if (stackMessage) {\r\n    texts.push('\\n', stackMessage);\r\n  }\r\n\r\n  // Log to file\r\n  if (logging.toFile) {\r\n    _logToFile(texts, prefix);\r\n  }\r\n\r\n  // Log to console\r\n  if (logging.toConsole) {\r\n    console.log.apply(\r\n      undefined,\r\n      [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n        texts.shift()[colors[newLevel - 1]],\r\n        ...texts\r\n      ])\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n  logWithStack(\r\n    newLevel,\r\n    null,\r\n    [\r\n      `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n      ...(issues || []).map((issue) => `- ${issue.message}`)\r\n    ].join('\\n')\r\n  );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n  // Get options from the `loggingOptions` object\r\n  const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n  // Reset flags to the default values\r\n  logging.pathCreated = false;\r\n  logging.pathToLog = '';\r\n\r\n  // Set the logging level\r\n  setLogLevel(level);\r\n\r\n  // Set the console logging\r\n  enableConsoleLogging(toConsole);\r\n\r\n  // Set the file logging\r\n  enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n  if (\r\n    Number.isInteger(level) &&\r\n    level >= 0 &&\r\n    level <= logging.levelsDesc.length\r\n  ) {\r\n    // Update the module logging's `level` option\r\n    logging.level = level;\r\n  }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n  // Update the module logging's `toConsole` option\r\n  logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n  // Update the module logging's `toFile` option\r\n  logging.toFile = !!toFile;\r\n\r\n  // Set the `dest` and `file` options only if the file logging is enabled\r\n  if (logging.toFile) {\r\n    logging.dest = dest || 'log';\r\n    logging.file = file || 'highcharts-export-server.log';\r\n  }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array<string>} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n  if (!logging.pathCreated) {\r\n    // Create if does not exist\r\n    !existsSync(getAbsolutePath(logging.dest)) &&\r\n      mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n    // Create the full path\r\n    logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n    // We now assume the path is available, e.g. it's the responsibility\r\n    // of the user to create the path with the correct access rights.\r\n    logging.pathCreated = true;\r\n  }\r\n\r\n  // Add the content to a file\r\n  appendFile(\r\n    logging.pathToLog,\r\n    [prefix].concat(texts).join(' ') + '\\n',\r\n    (error) => {\r\n      if (error && logging.toFile && logging.pathCreated) {\r\n        logging.toFile = false;\r\n        logging.pathCreated = false;\r\n        logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n      }\r\n    }\r\n  );\r\n}\r\n\r\nexport default {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  setLogLevel,\r\n  enableConsoleLogging,\r\n  enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * It provides a default configuration object with predefined default values,\r\n * descriptions, and characteristics for each option used in the Export Server.\r\n */\r\n\r\n/**\r\n * The default configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option.\r\n * - Data types for validation.\r\n * - Names of corresponding environment variables.\r\n * - Descriptions of each property.\r\n * - Information used for prompts in interactive configuration.\r\n * - [Optional] Corresponding CLI argument names for CLI usage.\r\n * - [Optional] Legacy names from the previous PhantomJS-based server.\r\n */\r\nconst defaultConfig = {\r\n  puppeteer: {\r\n    args: {\r\n      value: [\r\n        '--allow-running-insecure-content',\r\n        '--ash-no-nudges',\r\n        '--autoplay-policy=user-gesture-required',\r\n        '--block-new-web-contents',\r\n        '--disable-accelerated-2d-canvas',\r\n        '--disable-background-networking',\r\n        '--disable-background-timer-throttling',\r\n        '--disable-backgrounding-occluded-windows',\r\n        '--disable-breakpad',\r\n        '--disable-checker-imaging',\r\n        '--disable-client-side-phishing-detection',\r\n        '--disable-component-extensions-with-background-pages',\r\n        '--disable-component-update',\r\n        '--disable-default-apps',\r\n        '--disable-dev-shm-usage',\r\n        '--disable-domain-reliability',\r\n        '--disable-extensions',\r\n        '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n        '--disable-hang-monitor',\r\n        '--disable-ipc-flooding-protection',\r\n        '--disable-logging',\r\n        '--disable-notifications',\r\n        '--disable-offer-store-unmasked-wallet-cards',\r\n        '--disable-popup-blocking',\r\n        '--disable-print-preview',\r\n        '--disable-prompt-on-repost',\r\n        '--disable-renderer-backgrounding',\r\n        '--disable-search-engine-choice-screen',\r\n        '--disable-session-crashed-bubble',\r\n        '--disable-setuid-sandbox',\r\n        '--disable-site-isolation-trials',\r\n        '--disable-speech-api',\r\n        '--disable-sync',\r\n        '--enable-unsafe-webgpu',\r\n        '--hide-crash-restore-bubble',\r\n        '--hide-scrollbars',\r\n        '--metrics-recording-only',\r\n        '--mute-audio',\r\n        '--no-default-browser-check',\r\n        '--no-first-run',\r\n        '--no-pings',\r\n        '--no-sandbox',\r\n        '--no-startup-window',\r\n        '--no-zygote',\r\n        '--password-store=basic',\r\n        '--process-per-tab',\r\n        '--use-mock-keychain'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'PUPPETEER_ARGS',\r\n      cliName: 'puppeteerArgs',\r\n      description: 'Array of Puppeteer arguments',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  highcharts: {\r\n    version: {\r\n      value: 'latest',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_VERSION',\r\n      description: 'Highcharts version',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    cdnUrl: {\r\n      value: 'https://code.highcharts.com',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CDN_URL',\r\n      description: 'CDN URL for Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    forceFetch: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n      description: 'Flag to refetch scripts after each server rerun',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    cachePath: {\r\n      value: '.cache',\r\n      types: ['string'],\r\n      envLink: 'HIGHCHARTS_CACHE_PATH',\r\n      description: 'Directory path for cached Highcharts scripts',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    coreScripts: {\r\n      value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n      description: 'Highcharts core scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    moduleScripts: {\r\n      value: [\r\n        'stock',\r\n        'map',\r\n        'gantt',\r\n        'exporting',\r\n        'parallel-coordinates',\r\n        'accessibility',\r\n        // 'annotations-advanced',\r\n        'boost-canvas',\r\n        'boost',\r\n        'data',\r\n        'data-tools',\r\n        'draggable-points',\r\n        'static-scale',\r\n        'broken-axis',\r\n        'heatmap',\r\n        'tilemap',\r\n        'tiledwebmap',\r\n        'timeline',\r\n        'treemap',\r\n        'treegraph',\r\n        'item-series',\r\n        'drilldown',\r\n        'histogram-bellcurve',\r\n        'bullet',\r\n        'funnel',\r\n        'funnel3d',\r\n        'geoheatmap',\r\n        'pyramid3d',\r\n        'networkgraph',\r\n        'overlapping-datalabels',\r\n        'pareto',\r\n        'pattern-fill',\r\n        'pictorial',\r\n        'price-indicator',\r\n        'sankey',\r\n        'arc-diagram',\r\n        'dependency-wheel',\r\n        'series-label',\r\n        'series-on-point',\r\n        'solid-gauge',\r\n        'sonification',\r\n        // 'stock-tools',\r\n        'streamgraph',\r\n        'sunburst',\r\n        'variable-pie',\r\n        'variwide',\r\n        'vector',\r\n        'venn',\r\n        'windbarb',\r\n        'wordcloud',\r\n        'xrange',\r\n        'no-data-to-display',\r\n        'drag-panes',\r\n        'debugger',\r\n        'dumbbell',\r\n        'lollipop',\r\n        'cylinder',\r\n        'organization',\r\n        'dotplot',\r\n        'marker-clusters',\r\n        'hollowcandlestick',\r\n        'heikinashi',\r\n        'flowmap',\r\n        'export-data',\r\n        'navigator',\r\n        'textpath'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n      description: 'Highcharts module scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    indicatorScripts: {\r\n      value: ['indicators-all'],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n      description: 'Highcharts indicator scripts to fetch',\r\n      promptOptions: {\r\n        type: 'multiselect',\r\n        instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n      }\r\n    },\r\n    customScripts: {\r\n      value: [\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n        'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n      ],\r\n      types: ['string[]'],\r\n      envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n      description: 'Additional custom scripts or dependencies to fetch',\r\n      promptOptions: {\r\n        type: 'list',\r\n        separator: ';'\r\n      }\r\n    }\r\n  },\r\n  export: {\r\n    infile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_INFILE',\r\n      description:\r\n        'Input filename with type, formatted correctly as JSON or SVG',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    instr: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_INSTR',\r\n      description:\r\n        'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    options: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_OPTIONS',\r\n      description: 'Alias for the `instr` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    svg: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_SVG',\r\n      description: 'SVG string representation of the chart to render',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    batch: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_BATCH',\r\n      description:\r\n        'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    outfile: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'EXPORT_OUTFILE',\r\n      description:\r\n        'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    type: {\r\n      value: 'png',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_TYPE',\r\n      description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: png',\r\n        choices: ['png', 'jpeg', 'pdf', 'svg']\r\n      }\r\n    },\r\n    constr: {\r\n      value: 'chart',\r\n      types: ['string'],\r\n      envLink: 'EXPORT_CONSTR',\r\n      description:\r\n        'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n      promptOptions: {\r\n        type: 'select',\r\n        hint: 'Default: chart',\r\n        choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n      }\r\n    },\r\n    b64: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_B64',\r\n      description:\r\n        'Whether or not to the chart should be received in Base64 format instead of binary',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noDownload: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'EXPORT_NO_DOWNLOAD',\r\n      description:\r\n        'Whether or not to include or exclude attachment headers in the response',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    height: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_HEIGHT',\r\n      description: 'Height of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    width: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_WIDTH',\r\n      description: 'Width of the exported chart, overrides chart settings',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    scale: {\r\n      value: null,\r\n      types: ['number', 'null'],\r\n      envLink: 'EXPORT_SCALE',\r\n      description:\r\n        'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultHeight: {\r\n      value: 400,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n      description: 'Default height of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultWidth: {\r\n      value: 600,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_WIDTH',\r\n      description: 'Default width of the exported chart if not set',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    defaultScale: {\r\n      value: 1,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_DEFAULT_SCALE',\r\n      description:\r\n        'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n      promptOptions: {\r\n        type: 'number',\r\n        min: 0.1,\r\n        max: 5\r\n      }\r\n    },\r\n    globalOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    themeOptions: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'EXPORT_THEME_OPTIONS',\r\n      description:\r\n        'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    rasterizationTimeout: {\r\n      value: 1500,\r\n      types: ['number'],\r\n      envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n      description: 'Milliseconds to wait for webpage rendering',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  },\r\n  customLogic: {\r\n    allowCodeExecution: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n      description:\r\n        'Allows or disallows execution of arbitrary code during exporting',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    allowFileResources: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n      description:\r\n        'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    customCode: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n      description:\r\n        'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    callback: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n      description:\r\n        'JavaScript code to run during construction. Can be a function or a .js filename',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    resources: {\r\n      value: null,\r\n      types: ['Object', 'string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n      description:\r\n        'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    loadConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n      legacyName: 'fromFile',\r\n      description: 'File with a pre-defined configuration to use',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    createConfig: {\r\n      value: null,\r\n      types: ['string', 'null'],\r\n      envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n      description:\r\n        'Prompt-based option setting, saved to a provided config file',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  server: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_ENABLE',\r\n      cliName: 'enableServer',\r\n      description: 'Starts the server when true',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    host: {\r\n      value: '0.0.0.0',\r\n      types: ['string'],\r\n      envLink: 'SERVER_HOST',\r\n      description: 'Hostname of the server',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    port: {\r\n      value: 7801,\r\n      types: ['number'],\r\n      envLink: 'SERVER_PORT',\r\n      description: 'Port number for the server',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    uploadLimit: {\r\n      value: 3,\r\n      types: ['number'],\r\n      envLink: 'SERVER_UPLOAD_LIMIT',\r\n      description: 'Maximum request body size in MB',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'SERVER_BENCHMARKING',\r\n      cliName: 'serverBenchmarking',\r\n      description:\r\n        'Displays or not action durations in milliseconds during server requests',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    proxy: {\r\n      host: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_PROXY_HOST',\r\n        cliName: 'proxyHost',\r\n        description: 'Host of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      port: {\r\n        value: null,\r\n        types: ['number', 'null'],\r\n        envLink: 'SERVER_PROXY_PORT',\r\n        cliName: 'proxyPort',\r\n        description: 'Port of the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      timeout: {\r\n        value: 5000,\r\n        types: ['number'],\r\n        envLink: 'SERVER_PROXY_TIMEOUT',\r\n        cliName: 'proxyTimeout',\r\n        description:\r\n          'Timeout in milliseconds for the proxy server, if applicable',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      }\r\n    },\r\n    rateLimiting: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n        cliName: 'enableRateLimiting',\r\n        description: 'Enables or disables rate limiting on the server',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      maxRequests: {\r\n        value: 10,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n        legacyName: 'rateLimit',\r\n        description: 'Maximum number of requests allowed per minute',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      window: {\r\n        value: 1,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n        description: 'Time window in minutes for rate limiting',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      delay: {\r\n        value: 0,\r\n        types: ['number'],\r\n        envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n        description:\r\n          'Delay duration between successive requests before reaching the limit',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      trustProxy: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n        description: 'Set to true if the server is behind a load balancer',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      skipKey: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n        description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      },\r\n      skipToken: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n        description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    },\r\n    ssl: {\r\n      enable: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_ENABLE',\r\n        cliName: 'enableSsl',\r\n        description: 'Enables or disables SSL protocol',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      force: {\r\n        value: false,\r\n        types: ['boolean'],\r\n        envLink: 'SERVER_SSL_FORCE',\r\n        cliName: 'sslForce',\r\n        legacyName: 'sslOnly',\r\n        description: 'Forces the server to use HTTPS only when true',\r\n        promptOptions: {\r\n          type: 'toggle'\r\n        }\r\n      },\r\n      port: {\r\n        value: 443,\r\n        types: ['number'],\r\n        envLink: 'SERVER_SSL_PORT',\r\n        cliName: 'sslPort',\r\n        description: 'Port for the SSL server',\r\n        promptOptions: {\r\n          type: 'number'\r\n        }\r\n      },\r\n      certPath: {\r\n        value: null,\r\n        types: ['string', 'null'],\r\n        envLink: 'SERVER_SSL_CERT_PATH',\r\n        cliName: 'sslCertPath',\r\n        legacyName: 'sslPath',\r\n        description: 'Path to the SSL certificate/key file',\r\n        promptOptions: {\r\n          type: 'text'\r\n        }\r\n      }\r\n    }\r\n  },\r\n  pool: {\r\n    minWorkers: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'POOL_MIN_WORKERS',\r\n      description: 'Minimum and initial number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    maxWorkers: {\r\n      value: 8,\r\n      types: ['number'],\r\n      envLink: 'POOL_MAX_WORKERS',\r\n      legacyName: 'workers',\r\n      description: 'Maximum number of pool workers to spawn',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    workLimit: {\r\n      value: 40,\r\n      types: ['number'],\r\n      envLink: 'POOL_WORK_LIMIT',\r\n      description: 'Number of tasks a worker can handle before restarting',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    acquireTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for acquiring a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for creating a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    destroyTimeout: {\r\n      value: 5000,\r\n      types: ['number'],\r\n      envLink: 'POOL_DESTROY_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying a resource',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    idleTimeout: {\r\n      value: 30000,\r\n      types: ['number'],\r\n      envLink: 'POOL_IDLE_TIMEOUT',\r\n      description: 'Timeout in milliseconds for destroying idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    createRetryInterval: {\r\n      value: 200,\r\n      types: ['number'],\r\n      envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds before retrying resource creation on failure',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    reaperInterval: {\r\n      value: 1000,\r\n      types: ['number'],\r\n      envLink: 'POOL_REAPER_INTERVAL',\r\n      description:\r\n        'Interval in milliseconds to check and destroy idle resources',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    benchmarking: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'POOL_BENCHMARKING',\r\n      cliName: 'poolBenchmarking',\r\n      description: 'Shows statistics for the pool of resources',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  logging: {\r\n    level: {\r\n      value: 4,\r\n      types: ['number'],\r\n      envLink: 'LOGGING_LEVEL',\r\n      cliName: 'logLevel',\r\n      description: 'Logging verbosity level',\r\n      promptOptions: {\r\n        type: 'number',\r\n        round: 0,\r\n        min: 0,\r\n        max: 5\r\n      }\r\n    },\r\n    file: {\r\n      value: 'highcharts-export-server.log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_FILE',\r\n      cliName: 'logFile',\r\n      description:\r\n        'Log file name. Requires `logToFile` and `logDest` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    dest: {\r\n      value: 'log',\r\n      types: ['string'],\r\n      envLink: 'LOGGING_DEST',\r\n      cliName: 'logDest',\r\n      description: 'Path to store log files. Requires `logToFile` to be set',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    toConsole: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_CONSOLE',\r\n      cliName: 'logToConsole',\r\n      description: 'Enables or disables console logging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    toFile: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'LOGGING_TO_FILE',\r\n      cliName: 'logToFile',\r\n      description: 'Enables or disables logging to a file',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  ui: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'UI_ENABLE',\r\n      cliName: 'enableUi',\r\n      description: 'Enables or disables the UI for the export server',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    route: {\r\n      value: '/',\r\n      types: ['string'],\r\n      envLink: 'UI_ROUTE',\r\n      cliName: 'uiRoute',\r\n      description: 'The endpoint route for the UI',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    }\r\n  },\r\n  other: {\r\n    nodeEnv: {\r\n      value: 'production',\r\n      types: ['string'],\r\n      envLink: 'OTHER_NODE_ENV',\r\n      description: 'The Node.js environment type',\r\n      promptOptions: {\r\n        type: 'text'\r\n      }\r\n    },\r\n    listenToProcessExits: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n      description: 'Whether or not to attach process.exit handlers',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    noLogo: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_NO_LOGO',\r\n      description: 'Display or skip printing the logo on startup',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    hardResetPage: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_HARD_RESET_PAGE',\r\n      description: 'Whether or not to reset the page content entirely',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    browserShellMode: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n      description: 'Whether or not to set the browser to run in shell mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    validation: {\r\n      value: true,\r\n      types: ['boolean'],\r\n      envLink: 'OTHER_VALIDATION',\r\n      description: 'Whether or not to enable validation of options types',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    }\r\n  },\r\n  debug: {\r\n    enable: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_ENABLE',\r\n      cliName: 'enableDebug',\r\n      description: 'Enables or disables debug mode for the underlying browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    headless: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_HEADLESS',\r\n      description:\r\n        'Whether or not to set the browser to run in headless mode during debugging',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    devtools: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DEVTOOLS',\r\n      description: 'Enables or disables DevTools in headful mode',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    listenToConsole: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n      description:\r\n        'Enables or disables listening to console messages from the browser',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    dumpio: {\r\n      value: false,\r\n      types: ['boolean'],\r\n      envLink: 'DEBUG_DUMPIO',\r\n      description:\r\n        'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n      promptOptions: {\r\n        type: 'toggle'\r\n      }\r\n    },\r\n    slowMo: {\r\n      value: 0,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_SLOW_MO',\r\n      description: 'Delays Puppeteer operations by the specified milliseconds',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    },\r\n    debuggingPort: {\r\n      value: 9222,\r\n      types: ['number'],\r\n      envLink: 'DEBUG_DEBUGGING_PORT',\r\n      description: 'Port used for debugging',\r\n      promptOptions: {\r\n        type: 'number'\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\nexport default defaultConfig;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n  defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n  /**\r\n   * The `boolean` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept values are true\r\n   * and false and the schema will validate against the default boolean\r\n   * validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept values are true,\r\n   * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n   * The strings 'undefined', 'null', and '' will be transformed to null,\r\n   * the string 'true' will be transformed to the boolean value true,\r\n   * and 'false' will be transformed to the boolean value false.\r\n   *\r\n   * @function boolean\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n   */\r\n  boolean(strictCheck) {\r\n    return strictCheck\r\n      ? z.boolean()\r\n      : z\r\n          .union([\r\n            z\r\n              .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? value === 'true' || value === '1'\r\n                  : null\r\n              ),\r\n            z.boolean()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `string` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n   * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed strings\r\n   * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n   * be transformed to null.\r\n   *\r\n   * @function string\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n   */\r\n  string(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: 'The string contains a forbidden value'\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .transform((value) =>\r\n            !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `enum` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `values` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will validate against the `values`\r\n   * array with the default enum validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', and '', which will be transformed to null.\r\n   *\r\n   * @function enum\r\n   *\r\n   * @param {Array.<string>} values - An array of valid string values\r\n   * for the enum.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n   */\r\n  enum(values, strictCheck) {\r\n    return strictCheck\r\n      ? z.enum([...values])\r\n      : z\r\n          .enum([...values, 'undefined', 'null', ''])\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `stringArray` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n   * string values filtered by the logic provided through the `filterCallback`.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept null and trimmed\r\n   * string values which will be splitted into an array of strings and filtered\r\n   * from the '[' and ']' characters and by the logic provided through\r\n   * the `filterCallback`. If the array is empty, it will be transformed\r\n   * to null.\r\n   *\r\n   * @function stringArray\r\n   *\r\n   * @param {function} filterCallback - The filter callback.\r\n   * @param {string} separator - The separator for spliting a string.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n   * values.\r\n   */\r\n  stringArray(filterCallback, separator, strictCheck) {\r\n    const arraySchema = z.string().trim().array();\r\n    const stringSchema = z\r\n      .string()\r\n      .trim()\r\n      .transform((value) => {\r\n        if (value.startsWith('[')) {\r\n          value = value.slice(1);\r\n        }\r\n        if (value.endsWith(']')) {\r\n          value = value.slice(0, -1);\r\n        }\r\n        return value.split(separator);\r\n      });\r\n\r\n    const transformCallback = (value) =>\r\n      value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n    return strictCheck\r\n      ? arraySchema.transform(transformCallback)\r\n      : z\r\n          .union([stringSchema, arraySchema])\r\n          .transform(transformCallback)\r\n          .transform((value) => (value.length ? value : null))\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `positiveNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept positive number values\r\n   * and validate against the default positive number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept positive number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a positive number. It will transform the string\r\n   * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n   *\r\n   * @function positiveNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n   * values.\r\n   */\r\n  positiveNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().positive()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) > 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and positive'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().positive()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept non-negative number\r\n   * values and validate against the default non-negative number validator.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept non-negative number\r\n   * values, null, and trimmed string values that can either be 'undefined',\r\n   * 'null', '', or represent a non-negative number. It will transform\r\n   * the string to a non-negative number, or to null if it is 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function nonNegativeNum\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n   * number values.\r\n   */\r\n  nonNegativeNum(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().nonnegative()\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be numeric and non-negative'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().nonnegative()\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `startsWith` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The schema will validate against the provided `prefixes` array to check\r\n   * whether a string value starts with any of the values provided\r\n   * in the `prefixes` array.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that start with values from the prefixes array, null, 'undefined', 'null',\r\n   * and '' where the schema will transform them to null.\r\n   *\r\n   * @function startsWith\r\n   *\r\n   * @param {Array.<string>} prefixes - An array of prefixes to validate\r\n   * the string against.\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n   * starts with values.\r\n   */\r\n  startsWith(prefixes, strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `chartConfig` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements, start\r\n   * with the '{' and end with the '}', and null. The 'undefined', 'null',\r\n   * and '' values will be transformed to null.\r\n   *\r\n   * @function chartConfig\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating chart\r\n   * configuration value.\r\n   */\r\n  chartConfig() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `additionalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that end with '.json' and are at least one\r\n   * character long excluding the extension, start with the '{' and end\r\n   * with the '}', and null. The 'undefined', 'null', and '' values will\r\n   * be transformed to null.\r\n   *\r\n   * @function additionalOptions\r\n   *\r\n   * @returns {z.ZodSchema}  A Zod schema object for validating additional chart\r\n   * options value.\r\n   */\r\n  additionalOptions() {\r\n    return z\r\n      .union([\r\n        z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.startsWith('{') && value.endsWith('}')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          ),\r\n        z.object({}).passthrough()\r\n      ])\r\n      .nullable();\r\n  }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n  /**\r\n   * The `args` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function args\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n   * option.\r\n   */\r\n  args(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n      ';',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `version` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n   * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n   * version option.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept also null,\r\n   * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n   * to null.\r\n   *\r\n   * @function version\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n   * option.\r\n   */\r\n  version(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n            params: {\r\n              errorMessage:\r\n                \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n            }\r\n          })\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function cdnUrl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n   * option.\r\n   */\r\n  cdnUrl(strictCheck) {\r\n    return v.startsWith(['http://', 'https://'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `forceFetch` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function forceFetch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n   * option.\r\n   */\r\n  forceFetch(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `cachePath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function cachePath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n   * option.\r\n   */\r\n  cachePath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `adminToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function adminToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n   * option.\r\n   */\r\n  adminToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `coreScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function coreScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n   * option.\r\n   */\r\n  coreScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => coreScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `moduleScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function moduleScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `moduleScripts` option.\r\n   */\r\n  moduleScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => moduleScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function indicatorScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `indicatorScripts` option.\r\n   */\r\n  indicatorScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => indicatorScripts.value.includes(value),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `customScripts` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `stringArray` validator.\r\n   *\r\n   * @function customScripts\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `customScripts` option.\r\n   */\r\n  customScripts(strictCheck) {\r\n    return v.stringArray(\r\n      (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n      ',',\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `infile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.json' or '.svg', are at least one character long excluding\r\n   * the extension and will be null if the provided value is null, 'undefined',\r\n   * 'null', or ''.\r\n   *\r\n   * @function infile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n   * option.\r\n   */\r\n  infile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.json')) ||\r\n              (value.length >= 5 && value.endsWith('.svg')) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .json or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `instr` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function instr\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n   * option.\r\n   */\r\n  instr() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `options` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `options` validator.\r\n   *\r\n   * @function options\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n   * option.\r\n   */\r\n  options() {\r\n    return v.chartConfig();\r\n  },\r\n\r\n  /**\r\n   * The `svg` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures that the schema will accept object values\r\n   * or trimmed string values that contain '<svg' or '<?xml' elements and null.\r\n   * The 'undefined', 'null', and '' values will be transformed to null.\r\n   *\r\n   * @function svg\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `svg` option.\r\n   */\r\n  svg() {\r\n    return z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          value.indexOf('<svg') >= 0 ||\r\n          value.indexOf('<?xml') >= 0 ||\r\n          ['false', 'undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that contains '<svg' or '<?xml'\"\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n      )\r\n      .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `outfile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension, or null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept trimmed string values\r\n   * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n   * character long excluding the extension and will be null if the provided\r\n   * value is null, 'undefined', 'null', or ''.\r\n   *\r\n   * @function outfile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n   * option.\r\n   */\r\n  outfile(strictCheck) {\r\n    return strictCheck\r\n      ? z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .nullable()\r\n      : z\r\n          .string()\r\n          .trim()\r\n          .refine(\r\n            (value) =>\r\n              (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n              (value.length >= 5 &&\r\n                (value.endsWith('.jpg') ||\r\n                  value.endsWith('.png') ||\r\n                  value.endsWith('.pdf') ||\r\n                  value.endsWith('.svg'))) ||\r\n              ['undefined', 'null', ''].includes(value),\r\n            {\r\n              params: {\r\n                errorMessage:\r\n                  'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n              }\r\n            }\r\n          )\r\n          .transform((value) =>\r\n            !['undefined', 'null', ''].includes(value) ? value : null\r\n          )\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `type` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function type\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n   * option.\r\n   */\r\n  type(strictCheck) {\r\n    return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `constr` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function constr\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n   * option.\r\n   */\r\n  constr(strictCheck) {\r\n    return v.enum(\r\n      ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n      strictCheck\r\n    );\r\n  },\r\n\r\n  /**\r\n   * The `b64` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function b64\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n   */\r\n  b64(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noDownload` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noDownload\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n   * option.\r\n   */\r\n  noDownload(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultHeight` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultHeight\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultHeight` option.\r\n   */\r\n  defaultHeight(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultWidth` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function defaultWidth\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultWidth` option.\r\n   */\r\n  defaultWidth(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `defaultScale` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept number values that\r\n   * are between 0.1 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept number values\r\n   * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n   * 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function defaultScale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `defaultScale` option.\r\n   */\r\n  defaultScale(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().gte(0.1).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number(value) >= 0.1 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().gte(0.1).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `height` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultHeight`\r\n   * validator.\r\n   *\r\n   * @function height\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n   * option.\r\n   */\r\n  height(strictCheck) {\r\n    return this.defaultHeight(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `width` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultWidth`\r\n   * validator.\r\n   *\r\n   * @function width\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n   * option.\r\n   */\r\n  width(strictCheck) {\r\n    return this.defaultWidth(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `scale` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `defaultScale`\r\n   * validator.\r\n   *\r\n   * @function scale\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n   * option.\r\n   */\r\n  scale(strictCheck) {\r\n    return this.defaultScale(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `globalOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function globalOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `globalOptions` option.\r\n   */\r\n  globalOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `themeOptions` validator that returns a Zod schema.\r\n   *\r\n   * The validation schema ensures the same work as the `additionalOptions`\r\n   * validator.\r\n   *\r\n   * @function themeOptions\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `themeOptions` option.\r\n   */\r\n  themeOptions() {\r\n    return v.additionalOptions();\r\n  },\r\n\r\n  /**\r\n   * The `batch` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function batch\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n   * option.\r\n   */\r\n  batch(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `rasterizationTimeout` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function rasterizationTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `rasterizationTimeout` option.\r\n   */\r\n  rasterizationTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowCodeExecution` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowCodeExecution\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowCodeExecution` option.\r\n   */\r\n  allowCodeExecution(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `allowFileResources` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function allowFileResources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `allowFileResources` option.\r\n   */\r\n  allowFileResources(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `customCode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function customCode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n   * option.\r\n   */\r\n  customCode(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `callback` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function callback\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n   * option.\r\n   */\r\n  callback(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resources` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept a partial object\r\n   * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n   * properties can be null, stringified version of the object, string that ends\r\n   * with the '.json', and null.\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept a stringified version\r\n   * of a partial object with allowed properties `js`, `css`, and `files` where\r\n   * each of the allowed properties can be null, string that ends with the\r\n   * '.json', and will be null if the provided value is 'undefined', 'null'\r\n   * or ''.\r\n   *\r\n   * @function resources\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n   * option.\r\n   */\r\n  resources(strictCheck) {\r\n    const objectSchema = z\r\n      .object({\r\n        js: v.string(false),\r\n        css: v.string(false),\r\n        files: v\r\n          .stringArray(\r\n            (value) => !['undefined', 'null', ''].includes(value),\r\n            ',',\r\n            true\r\n          )\r\n          .nullable()\r\n      })\r\n      .partial();\r\n\r\n    const stringSchema1 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage:\r\n              \"The value must be a string that starts with '{' and ends with '}\"\r\n          }\r\n        }\r\n      );\r\n\r\n    const stringSchema2 = z\r\n      .string()\r\n      .trim()\r\n      .refine(\r\n        (value) =>\r\n          (value.startsWith('{') && value.endsWith('}')) ||\r\n          (value.length >= 6 && value.endsWith('.json')) ||\r\n          ['undefined', 'null', ''].includes(value),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      )\r\n      .transform((value) =>\r\n        !['undefined', 'null', ''].includes(value) ? value : null\r\n      );\r\n\r\n    return strictCheck\r\n      ? z.union([objectSchema, stringSchema1]).nullable()\r\n      : z.union([objectSchema, stringSchema2]).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `loadConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.json'.\r\n   *\r\n   * @function loadConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n   * option.\r\n   */\r\n  loadConfig(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 6 && value.endsWith('.json')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .json'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `createConfig` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `loadConfig` validator.\r\n   *\r\n   * @function createConfig\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createConfig` option.\r\n   */\r\n  createConfig(strictCheck) {\r\n    return this.loadConfig(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableServer` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableServer\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableServer` option.\r\n   */\r\n  enableServer(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `host` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function host\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n   * option.\r\n   */\r\n  host(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `port` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function port\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n   * option.\r\n   */\r\n  port(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uploadLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function uploadLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n   * option.\r\n   */\r\n  uploadLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `serverBenchmarking` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function serverBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `serverBenchmarking` option.\r\n   */\r\n  serverBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyHost` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function proxyHost\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n   * option.\r\n   */\r\n  proxyHost(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `proxyPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n   * option.\r\n   */\r\n  proxyPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck).nullable();\r\n  },\r\n\r\n  /**\r\n   * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function proxyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `proxyTimeout` option.\r\n   */\r\n  proxyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableRateLimiting` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableRateLimiting\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `enableRateLimiting` option.\r\n   */\r\n  enableRateLimiting(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxRequests` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function maxRequests\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n   * option.\r\n   */\r\n  maxRequests(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `window` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function window\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n   * option.\r\n   */\r\n  window(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `delay` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function delay\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n   * option.\r\n   */\r\n  delay(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `trustProxy` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function trustProxy\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n   * option.\r\n   */\r\n  trustProxy(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipKey\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n   * option.\r\n   */\r\n  skipKey(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `skipToken` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function skipToken\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n   * option.\r\n   */\r\n  skipToken(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableSsl` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableSsl\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n   * option.\r\n   */\r\n  enableSsl(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslForce` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function sslForce\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n   * option.\r\n   */\r\n  sslForce(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function sslPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n   * option.\r\n   */\r\n  sslPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `sslCertPath` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function sslCertPath\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n   * option.\r\n   */\r\n  sslCertPath(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `minWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function minWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n   * option.\r\n   */\r\n  minWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `maxWorkers` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function maxWorkers\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n   * option.\r\n   */\r\n  maxWorkers(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `workLimit` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `positiveNum` validator.\r\n   *\r\n   * @function workLimit\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n   * option.\r\n   */\r\n  workLimit(strictCheck) {\r\n    return v.positiveNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function acquireTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `acquireTimeout` option.\r\n   */\r\n  acquireTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createTimeout` option.\r\n   */\r\n  createTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function destroyTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `destroyTimeout` option.\r\n   */\r\n  destroyTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `idleTimeout` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function idleTimeout\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `idleTimeout` option.\r\n   */\r\n  idleTimeout(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `createRetryInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function createRetryInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `createRetryInterval` option.\r\n   */\r\n  createRetryInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `reaperInterval` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function reaperInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `reaperInterval` option.\r\n   */\r\n  reaperInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function poolBenchmarking\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `poolBenchmarking` option.\r\n   */\r\n  poolBenchmarking(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `resourcesInterval` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function resourcesInterval\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `resourcesInterval` option.\r\n   */\r\n  resourcesInterval(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logLevel` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures that:\r\n   *\r\n   * - When `strictCheck` is true, the schema will accept integer number values\r\n   * that are between 0 and 5 (inclusive).\r\n   *\r\n   * - When `strictCheck` is false, the schema will accept integer number values\r\n   * and stringified integer number values that are between 1 and 5 (inclusive),\r\n   * null, 'undefined', 'null', and '' which will be transformed to null.\r\n   *\r\n   * @function logLevel\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n   * option.\r\n   */\r\n  logLevel(strictCheck) {\r\n    return strictCheck\r\n      ? z.number().int().gte(0).lte(5)\r\n      : z\r\n          .union([\r\n            z\r\n              .string()\r\n              .trim()\r\n              .refine(\r\n                (value) =>\r\n                  (!isNaN(Number(value)) &&\r\n                    value !== true &&\r\n                    !value.startsWith('[') &&\r\n                    Number.isInteger(Number(value)) &&\r\n                    Number(value) >= 0 &&\r\n                    Number(value) <= 5) ||\r\n                  ['undefined', 'null', ''].includes(value),\r\n                {\r\n                  params: {\r\n                    errorMessage: 'The value must be within a 0 and 5 range'\r\n                  }\r\n                }\r\n              )\r\n              .transform((value) =>\r\n                !['undefined', 'null', ''].includes(value)\r\n                  ? Number(value)\r\n                  : null\r\n              ),\r\n            z.number().int().gte(0).lte(5)\r\n          ])\r\n          .nullable();\r\n  },\r\n\r\n  /**\r\n   * The `logFile` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a string that ends with '.log'.\r\n   *\r\n   * @function logFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n   * option.\r\n   */\r\n  logFile(strictCheck) {\r\n    return v\r\n      .string(strictCheck)\r\n      .refine(\r\n        (value) =>\r\n          value === null || (value.length >= 5 && value.endsWith('.log')),\r\n        {\r\n          params: {\r\n            errorMessage: 'The value must be a string that ends with .log'\r\n          }\r\n        }\r\n      );\r\n  },\r\n\r\n  /**\r\n   * The `logDest` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   *\r\n   * @function logDest\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n   * option.\r\n   */\r\n  logDest(strictCheck) {\r\n    return v.string(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `logToConsole` option.\r\n   */\r\n  logToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `logToFile` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function logToFile\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n   * option.\r\n   */\r\n  logToFile(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableUi` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableUi\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n   * option.\r\n   */\r\n  enableUi(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `uiRoute` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `startsWith` validator.\r\n   *\r\n   * @function uiRoute\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n   * option.\r\n   */\r\n  uiRoute(strictCheck) {\r\n    return v.startsWith(['/'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `nodeEnv` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `enum` validator.\r\n   *\r\n   * @function nodeEnv\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n   * option.\r\n   */\r\n  nodeEnv(strictCheck) {\r\n    return v.enum(['development', 'production', 'test'], strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToProcessExits` validator that returns a Zod schema with\r\n   * an optional stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToProcessExits\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToProcessExits` option.\r\n   */\r\n  listenToProcessExits(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `noLogo` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function noLogo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n   * option.\r\n   */\r\n  noLogo(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `hardResetPage` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function hardResetPage\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `hardResetPage` option.\r\n   */\r\n  hardResetPage(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `browserShellMode` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function browserShellMode\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `browserShellMode` option.\r\n   */\r\n  browserShellMode(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `validation` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function validation\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n   * option.\r\n   */\r\n  validation(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `enableDebug` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function enableDebug\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n   * option.\r\n   */\r\n  enableDebug(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `headless` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function headless\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n   * option.\r\n   */\r\n  headless(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `devtools` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function devtools\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n   * option.\r\n   */\r\n  devtools(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `listenToConsole` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function listenToConsole\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `listenToConsole` option.\r\n   */\r\n  listenToConsole(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `boolean` validator.\r\n   *\r\n   * @function dumpio\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n   * option.\r\n   */\r\n  dumpio(strictCheck) {\r\n    return v.boolean(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n   * check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function slowMo\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n   * option.\r\n   */\r\n  slowMo(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `debuggingPort` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `nonNegativeNum`\r\n   * validator.\r\n   *\r\n   * @function debuggingPort\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating\r\n   * the `debuggingPort` option.\r\n   */\r\n  debuggingPort(strictCheck) {\r\n    return v.nonNegativeNum(strictCheck);\r\n  },\r\n\r\n  /**\r\n   * The `requestId` validator that returns a Zod schema with an optional\r\n   * stricter check based on the `strictCheck` parameter.\r\n   *\r\n   * The validation schema ensures the same work as the `string` validator.\r\n   * Additionally, it must be a stringified UUID or can be null.\r\n   *\r\n   * @function requestId\r\n   *\r\n   * @param {boolean} strictCheck - Determines if stricter validation should\r\n   * be applied.\r\n   *\r\n   * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n   * option.\r\n   */\r\n  requestId() {\r\n    return z\r\n      .string()\r\n      .uuid({ message: 'The value must be a stringified UUID' })\r\n      .nullable();\r\n  }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      args: validators.args(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      version: validators.version(strictCheck),\r\n      cdnUrl: validators.cdnUrl(strictCheck),\r\n      forceFetch: validators.forceFetch(strictCheck),\r\n      cachePath: validators.cachePath(strictCheck),\r\n      coreScripts: validators.coreScripts(strictCheck),\r\n      moduleScripts: validators.moduleScripts(strictCheck),\r\n      indicatorScripts: validators.indicatorScripts(strictCheck),\r\n      customScripts: validators.customScripts(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      infile: validators.infile(strictCheck),\r\n      instr: validators.instr(),\r\n      options: validators.options(),\r\n      svg: validators.svg(),\r\n      outfile: validators.outfile(strictCheck),\r\n      type: validators.type(strictCheck),\r\n      constr: validators.constr(strictCheck),\r\n      b64: validators.b64(strictCheck),\r\n      noDownload: validators.noDownload(strictCheck),\r\n      defaultHeight: validators.defaultHeight(strictCheck),\r\n      defaultWidth: validators.defaultWidth(strictCheck),\r\n      defaultScale: validators.defaultScale(strictCheck),\r\n      height: validators.height(strictCheck),\r\n      width: validators.width(strictCheck),\r\n      scale: validators.scale(strictCheck),\r\n      globalOptions: validators.globalOptions(),\r\n      themeOptions: validators.themeOptions(),\r\n      batch: validators.batch(false),\r\n      rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n      allowFileResources: validators.allowFileResources(strictCheck),\r\n      customCode: validators.customCode(false),\r\n      callback: validators.callback(false),\r\n      resources: validators.resources(strictCheck),\r\n      loadConfig: validators.loadConfig(false),\r\n      createConfig: validators.createConfig(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      host: validators.proxyHost(false),\r\n      port: validators.proxyPort(strictCheck),\r\n      timeout: validators.proxyTimeout(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableRateLimiting(strictCheck),\r\n      maxRequests: validators.maxRequests(strictCheck),\r\n      window: validators.window(strictCheck),\r\n      delay: validators.delay(strictCheck),\r\n      trustProxy: validators.trustProxy(strictCheck),\r\n      skipKey: validators.skipKey(false),\r\n      skipToken: validators.skipToken(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableSsl(strictCheck),\r\n      force: validators.sslForce(strictCheck),\r\n      port: validators.sslPort(strictCheck),\r\n      certPath: validators.sslCertPath(false)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n  z.object({\r\n    enable: validators.enableServer(strictCheck).optional(),\r\n    host: validators.host(strictCheck).optional(),\r\n    port: validators.port(strictCheck).optional(),\r\n    uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n    benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n    proxy: ProxySchema(strictCheck).optional(),\r\n    rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n    ssl: SslSchema(strictCheck).optional()\r\n  });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      minWorkers: validators.minWorkers(strictCheck),\r\n      maxWorkers: validators.maxWorkers(strictCheck),\r\n      workLimit: validators.workLimit(strictCheck),\r\n      acquireTimeout: validators.acquireTimeout(strictCheck),\r\n      createTimeout: validators.createTimeout(strictCheck),\r\n      destroyTimeout: validators.destroyTimeout(strictCheck),\r\n      idleTimeout: validators.idleTimeout(strictCheck),\r\n      createRetryInterval: validators.createRetryInterval(strictCheck),\r\n      reaperInterval: validators.reaperInterval(strictCheck),\r\n      benchmarking: validators.poolBenchmarking(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      level: validators.logLevel(strictCheck),\r\n      file: validators.logFile(strictCheck),\r\n      dest: validators.logDest(strictCheck),\r\n      toConsole: validators.logToConsole(strictCheck),\r\n      toFile: validators.logToFile(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableUi(strictCheck),\r\n      route: validators.uiRoute(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      nodeEnv: validators.nodeEnv(strictCheck),\r\n      listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n      noLogo: validators.noLogo(strictCheck),\r\n      hardResetPage: validators.hardResetPage(strictCheck),\r\n      browserShellMode: validators.browserShellMode(strictCheck),\r\n      validation: validators.validation(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n  z\r\n    .object({\r\n      enable: validators.enableDebug(strictCheck),\r\n      headless: validators.headless(strictCheck),\r\n      devtools: validators.devtools(strictCheck),\r\n      listenToConsole: validators.listenToConsole(strictCheck),\r\n      dumpio: validators.dumpio(strictCheck),\r\n      slowMo: validators.slowMo(strictCheck),\r\n      debuggingPort: validators.debuggingPort(strictCheck)\r\n    })\r\n    .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(true),\r\n  highcharts: HighchartsSchema(true),\r\n  export: ExportSchema(true),\r\n  customLogic: CustomLogicSchema(true),\r\n  server: ServerSchema(true),\r\n  pool: PoolSchema(true),\r\n  logging: LoggingSchema(true),\r\n  ui: UiSchema(true),\r\n  other: OtherSchema(true),\r\n  debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n  requestId: validators.requestId(),\r\n  puppeteer: PuppeteerSchema(false),\r\n  highcharts: HighchartsSchema(false),\r\n  export: ExportSchema(false),\r\n  customLogic: CustomLogicSchema(false),\r\n  server: ServerSchema(false),\r\n  pool: PoolSchema(false),\r\n  logging: LoggingSchema(false),\r\n  ui: UiSchema(false),\r\n  other: OtherSchema(false),\r\n  debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n  // puppeteer\r\n  PUPPETEER_ARGS: validators.args(false),\r\n\r\n  // highcharts\r\n  HIGHCHARTS_VERSION: validators.version(false),\r\n  HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n  HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n  HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n  HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n  HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n  HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n  HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n  HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n  // export\r\n  EXPORT_INFILE: validators.infile(false),\r\n  EXPORT_INSTR: validators.instr(),\r\n  EXPORT_OPTIONS: validators.options(),\r\n  EXPORT_SVG: validators.svg(),\r\n  EXPORT_BATCH: validators.batch(false),\r\n  EXPORT_OUTFILE: validators.outfile(false),\r\n  EXPORT_TYPE: validators.type(false),\r\n  EXPORT_CONSTR: validators.constr(false),\r\n  EXPORT_B64: validators.b64(false),\r\n  EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n  EXPORT_HEIGHT: validators.height(false),\r\n  EXPORT_WIDTH: validators.width(false),\r\n  EXPORT_SCALE: validators.scale(false),\r\n  EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n  EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n  EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n  EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n  EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n  EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n  // custom\r\n  CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n  CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n  CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n  CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n  CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n  CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n  CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n  // server\r\n  SERVER_ENABLE: validators.enableServer(false),\r\n  SERVER_HOST: validators.host(false),\r\n  SERVER_PORT: validators.port(false),\r\n  SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n  SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n  // server proxy\r\n  SERVER_PROXY_HOST: validators.proxyHost(false),\r\n  SERVER_PROXY_PORT: validators.proxyPort(false),\r\n  SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n  // server rate limiting\r\n  SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n  SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n  SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n  SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n  SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n  SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n  SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n  // server ssl\r\n  SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n  SERVER_SSL_FORCE: validators.sslForce(false),\r\n  SERVER_SSL_PORT: validators.sslPort(false),\r\n  SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n  // pool\r\n  POOL_MIN_WORKERS: validators.minWorkers(false),\r\n  POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n  POOL_WORK_LIMIT: validators.workLimit(false),\r\n  POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n  POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n  POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n  POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n  POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n  POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n  POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n  // logging\r\n  LOGGING_LEVEL: validators.logLevel(false),\r\n  LOGGING_FILE: validators.logFile(false),\r\n  LOGGING_DEST: validators.logDest(false),\r\n  LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n  LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n  // ui\r\n  UI_ENABLE: validators.enableUi(false),\r\n  UI_ROUTE: validators.uiRoute(false),\r\n\r\n  // other\r\n  OTHER_NODE_ENV: validators.nodeEnv(false),\r\n  OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n  OTHER_NO_LOGO: validators.noLogo(false),\r\n  OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n  OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n  OTHER_VALIDATION: validators.validation(false),\r\n\r\n  // debugger\r\n  DEBUG_ENABLE: validators.enableDebug(false),\r\n  DEBUG_HEADLESS: validators.headless(false),\r\n  DEBUG_DEVTOOLS: validators.devtools(false),\r\n  DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n  DEBUG_DUMPIO: validators.dumpio(false),\r\n  DEBUG_SLOW_MO: validators.slowMo(false),\r\n  DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n  return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n  return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n  // Get the chain of properties which error directly refers to\r\n  const propertyName = issue.path.join('.');\r\n\r\n  // Create the first part of the message about the property information\r\n  const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n  // Modified message for the invalid type\r\n  if (issue.code === z.ZodIssueCode.invalid_type) {\r\n    // Modified message for the required values\r\n    if (issue.received === z.ZodParsedType.undefined) {\r\n      return {\r\n        message: `${propertyInfo} - No value was provided.`\r\n      };\r\n    }\r\n\r\n    // Modified message for the specific invalid type when values exist\r\n    return {\r\n      message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n    };\r\n  }\r\n\r\n  // Modified message for the custom validation\r\n  if (issue.code === z.ZodIssueCode.custom) {\r\n    // If the custom message for error exist, include it\r\n    if (issue.params?.errorMessage) {\r\n      return {\r\n        message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n      };\r\n    }\r\n  }\r\n\r\n  // Modified message for the invalid union error\r\n  if (issue.code === z.ZodIssueCode.invalid_union) {\r\n    // Create the first part of the message about the multiple errors\r\n    let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n    // Cycle through all errors and create a correct message\r\n    issue.unionErrors.forEach((value) => {\r\n      const index = value.issues[0].message.indexOf('-');\r\n      message +=\r\n        index !== -1\r\n          ? `${value.issues[0].message}\\n`.substring(index)\r\n          : `${value.issues[0].message}\\n`;\r\n    });\r\n\r\n    // Return the final message for the invalid union error\r\n    return {\r\n      message\r\n    };\r\n  }\r\n\r\n  // Return the default error message, extended by the info about the property\r\n  return {\r\n    message: `${propertyInfo} - ${context.defaultError}.`\r\n  };\r\n}\r\n\r\nexport default {\r\n  validators,\r\n  StrictConfigSchema,\r\n  LooseConfigSchema,\r\n  EnvSchema,\r\n  envs,\r\n  strictValidate,\r\n  looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n  /**\r\n   * Creates an instance of the `ExportError`.\r\n   *\r\n   * @param {string} message - The error message to be displayed.\r\n   * @param {number} statusCode - Optional HTTP status code associated\r\n   * with the error (e.g., 400, 500).\r\n   */\r\n  constructor(message, statusCode) {\r\n    super();\r\n\r\n    // Set the `message` and `stackMessage` with provided message\r\n    this.message = message;\r\n    this.stackMessage = message;\r\n\r\n    // Set the `statusCode` if provided\r\n    if (statusCode) {\r\n      this.statusCode = statusCode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets additional error details based on an existing error object.\r\n   *\r\n   * @param {Error} error - An error object containing details to populate\r\n   * the `ExportError` instance.\r\n   *\r\n   * @returns {ExportError} The updated instance of the `ExportError` class.\r\n   */\r\n  setError(error) {\r\n    // Save the provided error\r\n    this.error = error;\r\n\r\n    // Set the error's name if present\r\n    if (error.name) {\r\n      this.name = error.name;\r\n    }\r\n\r\n    // Set the error's status code if present\r\n    if (error.statusCode) {\r\n      this.statusCode = error.statusCode;\r\n    }\r\n\r\n    // Set the error's stack and stack's message if present\r\n    if (error.stack) {\r\n      this.stackMessage = error.message;\r\n      this.stack = error.stack;\r\n    }\r\n\r\n    // Return updated `ExportError` instance\r\n    return this;\r\n  }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module manages configuration for the Highcharts Export Server\r\n * by loading and merging options from multiple sources, such as the default\r\n * settings, environment variables, user-provided options, and command-line\r\n * arguments. Ensures the global options are up-to-date with the highest\r\n * priority values. Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n  envs,\r\n  looseValidate,\r\n  strictValidate,\r\n  validators\r\n} from './validation.js';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n// Properties nesting level of all options\r\nconst nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nconst absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or an original global options\r\n * object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `true`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n  // Return a copy or an original global options object\r\n  return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object or a copy of the global options\r\n * object, based on the `getCopy` flag. The `newOptions` object can be\r\n * strictly validated depending on the `strictCheck` flag.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false, strictCheck = true) {\r\n  // Merge new options to the global options or its copy and return the result\r\n  return _mergeOptions(\r\n    // First, get the options\r\n    getOptions(getCopy),\r\n    // Next, validate the new options\r\n    validateOptions(newOptions, strictCheck)\r\n  );\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object with values provided through\r\n * the CLI, keeping the principle of options load priority. The function accepts\r\n * a `cliArgs` array containing arguments from the CLI, which will be validated\r\n * and applied if provided.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from the command line interface (CLI).\r\n * 2. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array<string>} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n  // Only for the CLI usage\r\n  if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n    try {\r\n      // Get options from the custom JSON loaded via the `--loadConfig`\r\n      const configOptions = _loadConfigFile(cliArgs);\r\n\r\n      // Update global options with validated values from the `configOptions`\r\n      updateOptions(configOptions);\r\n    } catch (error) {\r\n      log(2, '[validation] No options added from the `--loadConfig` option.');\r\n    }\r\n\r\n    try {\r\n      // Get options from the CLI\r\n      const cliOptions = _pairArgumentValue(cliArgs);\r\n\r\n      // Update global options with validated values from the `cliOptions`\r\n      updateOptions(cliOptions, false, false);\r\n    } catch (error) {\r\n      log(2, '[validation] No options added from the CLI arguments.');\r\n    }\r\n  }\r\n\r\n  // Return reference to the global options\r\n  return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS-based) to a new format\r\n * (Puppeteer-based). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping provided\r\n * in the `nestedProps` object. The new format is used for Puppeteer, while\r\n * the old format was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in the `nestedProps` object or an empty object\r\n * if the provided `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n  // An object for the new structured options\r\n  const newOptions = {};\r\n\r\n  // Check if provided value is a correct object\r\n  if (isObject(oldOptions)) {\r\n    // Iterate over each key-value pair in the old-structured options\r\n    for (const [key, value] of Object.entries(oldOptions)) {\r\n      // If there is a nested mapping, split it into a properties chain\r\n      const propertiesChain = nestedProps[key]\r\n        ? nestedProps[key].split('.')\r\n        : [];\r\n\r\n      // If it is the last property in the chain, assign the value, otherwise,\r\n      // create or reuse the nested object\r\n      propertiesChain.reduce(\r\n        (obj, prop, index) =>\r\n          (obj[prop] =\r\n            propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n        newOptions\r\n      );\r\n    }\r\n  } else {\r\n    log(\r\n      2,\r\n      '[config] No correct object with options was provided. Returning an empty object.'\r\n    );\r\n  }\r\n\r\n  // Return the new, structured options object\r\n  return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n  // Return the original option if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOption;\r\n  }\r\n\r\n  try {\r\n    // Return validated option\r\n    return validators[name](strictCheck).parse(configOption);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(\r\n      1,\r\n      error.issues,\r\n      `[validation] The ${name} option validation error`\r\n    );\r\n\r\n    // Throw validation error\r\n    throw new ExportError(\r\n      `[validation] The ${name} option validation error`,\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n  // Return the original config if the validation is disabled\r\n  if (!getOptions().other.validation) {\r\n    return configOptions;\r\n  }\r\n\r\n  try {\r\n    // Return validated options\r\n    return strictCheck\r\n      ? strictValidate(configOptions)\r\n      : looseValidate(configOptions);\r\n  } catch (error) {\r\n    // Log Zod issues\r\n    logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n    // Throw validation error\r\n    throw new ExportError('[validation] Options validation error', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If `true`, functions are preserved. Otherwise, when\r\n * a function is found, `null` is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is `true`, and `null`\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n  config,\r\n  toString = false,\r\n  allowFunctions = false\r\n) {\r\n  try {\r\n    // Accept only objects and strings\r\n    if (!isObject(config) && typeof config !== 'string') {\r\n      // Return `null` if any other type\r\n      return null;\r\n    }\r\n\r\n    // Get the object representation of the original config\r\n    const objectConfig =\r\n      typeof config === 'string'\r\n        ? allowFunctions\r\n          ? eval(`(${config})`)\r\n          : JSON.parse(config)\r\n        : config;\r\n\r\n    // Preserve or remove potential functions based on the `allowFunctions` flag\r\n    const stringifiedOptions = _optionsStringify(\r\n      objectConfig,\r\n      allowFunctions,\r\n      false\r\n    );\r\n\r\n    // Parse the config to check if it is valid set of options\r\n    const parsedOptions = allowFunctions\r\n      ? JSON.parse(\r\n          _optionsStringify(objectConfig, allowFunctions, true),\r\n          (_, value) =>\r\n            typeof value === 'string' && value.startsWith('function')\r\n              ? eval(`(${value})`)\r\n              : value\r\n        )\r\n      : JSON.parse(stringifiedOptions);\r\n\r\n    // Return stringified or object options based on the `toString` flag\r\n    return toString ? stringifiedOptions : parsedOptions;\r\n  } catch (error) {\r\n    // Return `null` if parsing fails\r\n    return null;\r\n  }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from environment variables (specified in the `.env` file).\r\n * 2. Values from the `./lib/schemas/config.js` file (defaults).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n  // Init the object for options\r\n  const options = {};\r\n\r\n  // Start initializing the `options` object recursively\r\n  for (const [name, item] of Object.entries(config)) {\r\n    if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n      // Set the correct value based on the established priority order\r\n      if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n        // The environment variables value\r\n        options[name] = envs[item.envLink];\r\n      } else {\r\n        // The value from the config file\r\n        options[name] = item.value;\r\n      }\r\n    } else {\r\n      // Create a category of options in the `options` object\r\n      options[name] = _initOptions(item);\r\n    }\r\n  }\r\n\r\n  // Return the created `options` object\r\n  return options;\r\n}\r\n\r\n/**\r\n * Recursively merges two sets of configuration options, taking into account\r\n * properties specified in the `absoluteProps` array that require absolute\r\n * merging. The `originalOptions` object will be extended with options from\r\n * the `newOptions` object.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - The original configuration options object\r\n * to be extended.\r\n * @param {Object} newOptions - The new configuration options object to merge.\r\n *\r\n * @returns {Object} The extended `originalOptions` object.\r\n */\r\nfunction _mergeOptions(originalOptions, newOptions) {\r\n  // Check if the `originalOptions` and `newOptions` are correct objects\r\n  if (isObject(originalOptions) && isObject(newOptions)) {\r\n    for (const [key, value] of Object.entries(newOptions)) {\r\n      originalOptions[key] =\r\n        isObject(value) &&\r\n        !absoluteProps.includes(key) &&\r\n        originalOptions[key] !== undefined\r\n          ? _mergeOptions(originalOptions[key], value)\r\n          : value !== undefined\r\n            ? value\r\n            : originalOptions[key] || null;\r\n    }\r\n  }\r\n\r\n  // Return the original (modified or not) options\r\n  return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON string with the option\r\n * to preserve functions. In order for a function to be preserved, it needs\r\n * to follow the format `function (...) {...}`. Such a function can also\r\n * be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to `true`, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to `true`, functions are saved\r\n * as strings. The `allowFunctions` must be set to `true` as well for this\r\n * to take an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nfunction _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n  const replacerCallback = (_, value) => {\r\n    // Trim string values\r\n    if (typeof value === 'string') {\r\n      value = value.trim();\r\n    }\r\n\r\n    // If `value` is a function or stringified function\r\n    if (\r\n      typeof value === 'function' ||\r\n      (typeof value === 'string' &&\r\n        value.startsWith('function') &&\r\n        value.endsWith('}'))\r\n    ) {\r\n      // If the `allowFunctions` is set to `true`, preserve functions\r\n      if (allowFunctions) {\r\n        // Based on the `stringifyFunctions` options, set function values\r\n        return stringifyFunctions\r\n          ? // As stringified functions\r\n            `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n          : // As functions\r\n            `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n      } else {\r\n        // Throw an error otherwise\r\n        throw new Error();\r\n      }\r\n    }\r\n\r\n    // In all other cases, simply return the value\r\n    return value;\r\n  };\r\n\r\n  // Stringify options and if required, replace special functions marks\r\n  return JSON.stringify(options, replacerCallback).replaceAll(\r\n    stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n    ''\r\n  );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array<string>} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n  // Get the allow flags for the custom logic check\r\n  const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n  // Check if the `--loadConfig` option was used\r\n  const configIndex = cliArgs.findIndex(\r\n    (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n  );\r\n\r\n  // Get the `--loadConfig` option value\r\n  const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n  // Check if the `--loadConfig` is present and has a correct value\r\n  if (configFileName && allowFileResources) {\r\n    try {\r\n      // Load an optional custom JSON config file\r\n      return isAllowedConfig(\r\n        readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n        false,\r\n        allowCodeExecution\r\n      );\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[config] Unable to load the configuration from the ${configFileName} file.`\r\n      );\r\n    }\r\n  }\r\n\r\n  // No additional options to return\r\n  return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings in the `nestedProps` object.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array<string>} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(cliArgs) {\r\n  // An empty object to collect and structurize data from the args\r\n  const cliOptions = {};\r\n\r\n  // Cycle through all CLI args and filter them\r\n  for (let i = 0; i < cliArgs.length; i++) {\r\n    const option = cliArgs[i].replace(/-/g, '');\r\n\r\n    // Find the right place for property's value\r\n    const propertiesChain = nestedProps[option]\r\n      ? nestedProps[option].split('.')\r\n      : [];\r\n\r\n    // Create options object with values from CLI for later parsing and merging\r\n    propertiesChain.reduce((obj, prop, index) => {\r\n      if (propertiesChain.length - 1 === index) {\r\n        const value = cliArgs[++i];\r\n        if (!value) {\r\n          log(\r\n            2,\r\n            `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n          );\r\n        }\r\n        obj[prop] = value || null;\r\n      } else if (obj[prop] === undefined) {\r\n        obj[prop] = {};\r\n      }\r\n      return obj[prop];\r\n    }, cliOptions);\r\n  }\r\n\r\n  // Return parsed CLI options\r\n  return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.value === 'undefined') {\r\n      // Recurse into deeper levels of nested arguments\r\n      _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n    } else {\r\n      // Create the chain of nested arguments\r\n      nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n      // Support for the legacy, PhantomJS properties names\r\n      if (entry.legacyName !== undefined) {\r\n        nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the object with nested argument chains\r\n  return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * should be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array<string>} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array<string>} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n  Object.keys(config).forEach((key) => {\r\n    // Get the specific section\r\n    const entry = config[key];\r\n\r\n    // Check if there is still more depth to traverse\r\n    if (typeof entry.types === 'undefined') {\r\n      // Recurse into deeper levels\r\n      _createAbsoluteProps(entry, absoluteProps);\r\n    } else {\r\n      // If the option can be an object, save its type in the array\r\n      if (entry.types.includes('Object')) {\r\n        absoluteProps.push(key);\r\n      }\r\n    }\r\n  });\r\n\r\n  // Return the array with the names of absolute properties\r\n  return absoluteProps;\r\n}\r\n\r\nexport default {\r\n  getOptions,\r\n  updateOptions,\r\n  setCliOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions,\r\n  isAllowedConfig\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Sends a GET request to the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function get\r\n *\r\n * @param {string} url - The URL to get data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function get(url, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    // Decide on the protocol\r\n    _getProtocolModule(url)\r\n      .get(url, requestOptions, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          if (!responseData) {\r\n            reject('Nothing was fetched from the URL.');\r\n          }\r\n\r\n          // Get the full result and resolve the request\r\n          response.text = responseData;\r\n          resolve(response);\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n  });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n  return new Promise((resolve, reject) => {\r\n    const data = JSON.stringify(body);\r\n\r\n    // Set default headers and merge with `requestOptions`\r\n    const options = Object.assign(\r\n      {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'Content-Length': data.length\r\n        }\r\n      },\r\n      requestOptions\r\n    );\r\n\r\n    // Decide on the protocol\r\n    const request = _getProtocolModule(url)\r\n      .request(url, options, (response) => {\r\n        let responseData = '';\r\n\r\n        // A chunk of data has been received\r\n        response.on('data', (chunk) => {\r\n          responseData += chunk;\r\n        });\r\n\r\n        // The whole response has been received\r\n        response.on('end', () => {\r\n          try {\r\n            // Get the full result and resolve the request\r\n            response.text = responseData;\r\n            resolve(response);\r\n          } catch (error) {\r\n            reject(error);\r\n          }\r\n        });\r\n      })\r\n      .on('error', (error) => {\r\n        reject(error);\r\n      });\r\n\r\n    // Write the request body and end the request\r\n    request.write(data);\r\n    request.end();\r\n  });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (`http` or `https`).\r\n */\r\nfunction _getProtocolModule(url) {\r\n  return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { get } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n  cdnUrl: 'https://code.highcharts.com',\r\n  activeManifest: {},\r\n  sources: '',\r\n  hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkCache(highchartsOptions, serverProxyOptions) {\r\n  try {\r\n    let fetchedModules;\r\n\r\n    // Get the cache path\r\n    const cachePath = getCachePath();\r\n\r\n    // Prepare paths to manifest and sources from the cache folder\r\n    const manifestPath = join(cachePath, 'manifest.json');\r\n    const sourcePath = join(cachePath, 'sources.js');\r\n\r\n    // Create the cache destination if it doesn't exist already\r\n    !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n    // Fetch all the scripts either if the `manifest.json` does not exist\r\n    // or if the `forceFetch` option is enabled\r\n    if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n      log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n\r\n      // The initial cache update\r\n      fetchedModules = await _updateCache(\r\n        highchartsOptions,\r\n        serverProxyOptions,\r\n        sourcePath\r\n      );\r\n    } else {\r\n      let requestUpdate = false;\r\n\r\n      // Read the manifest JSON\r\n      const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n      // Check if the modules is an array, if so, we rewrite it to a map to make\r\n      // it easier to resolve modules\r\n      if (manifest.modules && Array.isArray(manifest.modules)) {\r\n        const moduleMap = {};\r\n        manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n        manifest.modules = moduleMap;\r\n      }\r\n\r\n      // Get the actual number of scripts to be fetched\r\n      const { coreScripts, moduleScripts, indicatorScripts } =\r\n        highchartsOptions;\r\n      const numberOfModules =\r\n        coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n      // Compare the loaded highcharts config with the contents in cache.\r\n      // If there are changes, fetch requested modules and products,\r\n      // and bake them into a giant blob. Save the blob.\r\n      if (manifest.version !== highchartsOptions.version) {\r\n        // Check the Highcharts version\r\n        log(\r\n          2,\r\n          '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else if (\r\n        Object.keys(manifest.modules || {}).length !== numberOfModules\r\n      ) {\r\n        // Check the number of modules\r\n        log(\r\n          2,\r\n          '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n        );\r\n        requestUpdate = true;\r\n      } else {\r\n        // Check each module, if anything is missing refetch everything\r\n        requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n          if (!manifest.modules[moduleName]) {\r\n            log(\r\n              2,\r\n              `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n            );\r\n            return true;\r\n          }\r\n        });\r\n      }\r\n\r\n      // Update cache if needed\r\n      if (requestUpdate) {\r\n        fetchedModules = await _updateCache(\r\n          highchartsOptions,\r\n          serverProxyOptions,\r\n          sourcePath\r\n        );\r\n      } else {\r\n        log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n        // Load the sources\r\n        cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n        // Get current modules map\r\n        fetchedModules = manifest.modules;\r\n\r\n        // Extract and save version of currently used Highcharts\r\n        cache.hcVersion = _extractHcVersion(cache.sources);\r\n      }\r\n    }\r\n\r\n    // Finally, save the new manifest, which is basically our current config\r\n    // in a slightly different format\r\n    await _saveConfigToManifest(highchartsOptions.version, fetchedModules);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Could not configure cache and create or update the config manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHcVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHcVersion() {\r\n  return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the scripts of a new version.\r\n *\r\n * @async\r\n * @function updateHcVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHcVersion(newVersion) {\r\n  // Update to the new version\r\n  const options = updateOptions({\r\n    highcharts: {\r\n      version: newVersion\r\n    }\r\n  });\r\n\r\n  // Check if cache needs to be updated\r\n  await checkCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n  return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n  return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {number} version - The currently used Highcharts version.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which modules\r\n * have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(version, fetchedModules = {}) {\r\n  // Update cache object with the current modules\r\n  cache.activeManifest = {\r\n    version,\r\n    modules: fetchedModules\r\n  };\r\n\r\n  log(3, '[cache] Writing a new manifest.');\r\n  try {\r\n    writeFileSync(\r\n      join(getCachePath(), 'manifest.json'),\r\n      JSON.stringify(cache.activeManifest),\r\n      'utf8'\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Error writing the cache manifest.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts content and information,\r\n * and used Highcharts version.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n  try {\r\n    // Get Highcharts version for scripts\r\n    const hcVersion =\r\n      highchartsOptions.version === 'latest'\r\n        ? null\r\n        : `${highchartsOptions.version}`;\r\n\r\n    log(\r\n      3,\r\n      `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n    );\r\n\r\n    // Get the CDN url for scripts\r\n    const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n    // Prepare options for a request\r\n    const requestOptions = _configureRequest(serverProxyOptions);\r\n\r\n    // An object to record which scripts are fetched\r\n    const fetchedModules = {};\r\n\r\n    // Join all fetched scripts and save in the manifest's sources\r\n    cache.sources = (\r\n      await Promise.all([\r\n        // Highcharts core scripts fetch\r\n        ...highchartsOptions.coreScripts.map((cs) =>\r\n          _fetchScript(\r\n            hcVersion ? `${cdnUrl}/${hcVersion}/${cs}` : `${cdnUrl}/${cs}`,\r\n            requestOptions,\r\n            fetchedModules,\r\n            true\r\n          )\r\n        ),\r\n        // Highcharts module scripts fetch\r\n        ...highchartsOptions.moduleScripts.map((ms) =>\r\n          _fetchScript(\r\n            ms === 'map'\r\n              ? hcVersion\r\n                ? `${cdnUrl}/maps/${hcVersion}/modules/${ms}`\r\n                : `${cdnUrl}/maps/modules/${ms}`\r\n              : hcVersion\r\n                ? `${cdnUrl}/${hcVersion}/modules/${ms}`\r\n                : `${cdnUrl}/modules/${ms}`,\r\n            requestOptions,\r\n            fetchedModules\r\n          )\r\n        ),\r\n        // Highcharts indicator scripts fetch\r\n        ...highchartsOptions.indicatorScripts.map((is) =>\r\n          _fetchScript(\r\n            hcVersion\r\n              ? `${cdnUrl}/stock/${hcVersion}/indicators/${is}`\r\n              : `${cdnUrl}/stock/indicators/${is}`,\r\n            requestOptions,\r\n            fetchedModules\r\n          )\r\n        ),\r\n        // Custom scripts fetch\r\n        ...highchartsOptions.customScripts.map((cs) =>\r\n          _fetchScript(`${cs}`, requestOptions)\r\n        )\r\n      ])\r\n    ).join(';\\n');\r\n\r\n    // Extract and save version of currently used Highcharts\r\n    cache.hcVersion = _extractHcVersion(cache.sources);\r\n\r\n    // Save the fetched modules into caches' source JSON\r\n    writeFileSync(sourcePath, cache.sources);\r\n\r\n    // Return the fetched modules\r\n    return fetchedModules;\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[cache] Unable to update the local Highcharts cache.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional requests options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchScript(\r\n  script,\r\n  requestOptions,\r\n  fetchedModules,\r\n  shouldThrowError = false\r\n) {\r\n  // Get rid of the .js from the custom strings\r\n  if (script.endsWith('.js')) {\r\n    script = script.substring(0, script.length - 3);\r\n  }\r\n  log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n  // Fetch the script\r\n  const response = await get(`${script}.js`, requestOptions);\r\n\r\n  // If OK, return its text representation\r\n  if (response.statusCode === 200 && typeof response.text == 'string') {\r\n    if (fetchedModules) {\r\n      const moduleName = _extractModuleName(script);\r\n      fetchedModules[moduleName] = 1;\r\n    }\r\n    return response.text;\r\n  }\r\n\r\n  // Based on the `shouldThrowError` flag, decide how to serve error message\r\n  if (shouldThrowError) {\r\n    throw new ExportError(\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n      404\r\n    ).setError(response);\r\n  } else {\r\n    log(\r\n      2,\r\n      `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Configures a proxy agent for outgoing HTTP requests based on the provided\r\n * `server.proxy` options. If a valid `host` and `port` are specified, it tries\r\n * to create an `HttpsProxyAgent`. If the creation fails, an `ExportError`\r\n * is thrown. If no proxy is configured, an empty object is returned.\r\n *\r\n * @function _configureRequest\r\n *\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n *\r\n * @returns {Object} The request options, including the proxy agent if created,\r\n * or an empty object if no proxy configuration is provided.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the proxy agent creation\r\n * fails.\r\n */\r\nfunction _configureRequest(serverProxyOptions) {\r\n  // Get the `host` and `port` of the proxy\r\n  const proxyHost = serverProxyOptions.host;\r\n  const proxyPort = serverProxyOptions.port;\r\n\r\n  // Try to create a proxy agent\r\n  if (proxyHost && proxyPort) {\r\n    try {\r\n      // Create the agent\r\n      const proxyAgent = new HttpsProxyAgent({\r\n        host: proxyHost,\r\n        port: proxyPort\r\n      });\r\n\r\n      // Add the agent to the request's options\r\n      return {\r\n        agent: proxyAgent,\r\n        timeout: serverProxyOptions.timeout\r\n      };\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[cache] Could not create a Proxy Agent.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n  }\r\n\r\n  // Return an empty object when no proxy agent is created\r\n  return {};\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function _extractHcVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nfunction _extractHcVersion(cacheSources) {\r\n  return cacheSources\r\n    .substring(0, cacheSources.indexOf('*/'))\r\n    .replace('/*', '')\r\n    .replace('*/', '')\r\n    .replace(/\\n/g, '')\r\n    .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the `scriptPath` property.\r\n *\r\n * @function _extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nfunction _extractModuleName(scriptPath) {\r\n  return scriptPath.replace(\r\n    /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n    ''\r\n  );\r\n}\r\n\r\nexport default {\r\n  checkCache,\r\n  getHcVersion,\r\n  updateHcVersion,\r\n  getCache,\r\n  getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n  Highcharts.animObject = function () {\r\n    return { duration: 0 };\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n  // Get required functions\r\n  const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n  // Create a separate object for a potential `setOptions` usages in order\r\n  // to prevent from polluting other exports that can happen on the same page\r\n  Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n  // NOTE: Is this used for anything useful?\r\n  window.isRenderComplete = false;\r\n  wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n    // Override the `userOptions` with image friendly options\r\n    userOptions = merge(userOptions, {\r\n      exporting: {\r\n        enabled: false\r\n      },\r\n      plotOptions: {\r\n        series: {\r\n          label: {\r\n            enabled: false\r\n          }\r\n        }\r\n      },\r\n      /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n        https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n        */\r\n      tooltip: {}\r\n    });\r\n\r\n    (userOptions.series || []).forEach(function (series) {\r\n      series.animation = false;\r\n    });\r\n\r\n    // Add flag to know if chart render has been called.\r\n    if (!window.onHighchartsRender) {\r\n      window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n        window.isRenderComplete = true;\r\n      });\r\n    }\r\n\r\n    proceed.apply(this, [userOptions, cb]);\r\n  });\r\n\r\n  wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n    proceed.apply(this, [chart, options]);\r\n  });\r\n\r\n  // Some mandatory additional `chart` and `exporting` options\r\n  const additionalOptions = {\r\n    chart: {\r\n      // By default animation is disabled\r\n      animation: false,\r\n      // Get the right size values\r\n      height: exportOptions.height,\r\n      width: exportOptions.width\r\n    },\r\n    exporting: {\r\n      // No need for the exporting button\r\n      enabled: false\r\n    }\r\n  };\r\n\r\n  // Get the input to export from the `instr` option\r\n  const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n  // Get the `themeOptions` option\r\n  const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n  // Merge the following options objects to create final options\r\n  const finalOptions = merge(\r\n    false,\r\n    themeOptions,\r\n    userOptions,\r\n    // Placed it here instead in the init because of the size issues\r\n    additionalOptions\r\n  );\r\n\r\n  // Prepare the `callback` option\r\n  const finalCallback = customLogicOptions.callback\r\n    ? new Function(`return ${customLogicOptions.callback}`)()\r\n    : null;\r\n\r\n  // Trigger the `customCode` option\r\n  if (customLogicOptions.customCode) {\r\n    new Function('options', customLogicOptions.customCode)(userOptions);\r\n  }\r\n\r\n  // Get the `globalOptions` option\r\n  const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n  // Set the global options if exist\r\n  if (globalOptions) {\r\n    setOptions(globalOptions);\r\n  }\r\n\r\n  // Call the chart creation\r\n  Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n  // Get all images from within the chart\r\n  const images = Array.from(\r\n    document.querySelectorAll('.highcharts-container image')\r\n  );\r\n\r\n  // Wait for all images for 2 seconds\r\n  await Promise.race([\r\n    Promise.all(\r\n      images.map((image) =>\r\n        image.complete && image.naturalHeight !== 0\r\n          ? Promise.resolve()\r\n          : new Promise((resolve) =>\r\n              image.addEventListener('load', resolve, { once: true })\r\n            )\r\n      )\r\n    ),\r\n    // Proceed further even if images did not load\r\n    new Promise((resolve) => setTimeout(resolve, 2000))\r\n  ]);\r\n\r\n  // Get the current global options\r\n  const defaultOptions = getOptions();\r\n\r\n  // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n  for (const prop in defaultOptions) {\r\n    if (typeof defaultOptions[prop] !== 'function') {\r\n      delete defaultOptions[prop];\r\n    }\r\n  }\r\n\r\n  // Set the default options back\r\n  setOptions(Highcharts.setOptionsObj);\r\n\r\n  // Empty the custom global options object\r\n  Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n  setupHighcharts,\r\n  createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom JS and CSS resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that the browser and pages are correctly managed and can handle failures\r\n * during operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst pageTemplate = readFileSync(\r\n  join(__dirname, 'templates', 'template.html'),\r\n  'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n  if (!browser) {\r\n    throw new ExportError('[browser] No valid browser has been created.', 500);\r\n  }\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * browser's launch.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n  // Get `debug` and `other` options\r\n  const { debug, other } = getOptions();\r\n\r\n  // Get the `debug` options\r\n  const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n  // Launch options for the browser instance\r\n  const launchOptions = {\r\n    headless: other.browserShellMode ? 'shell' : true,\r\n    userDataDir: 'tmp',\r\n    args: puppeteerArgs || [],\r\n    handleSIGINT: false,\r\n    handleSIGTERM: false,\r\n    handleSIGHUP: false,\r\n    waitForInitialPage: false,\r\n    defaultViewport: null,\r\n    ...(enabledDebug && debugOptions)\r\n  };\r\n\r\n  // Create a browser\r\n  if (!browser) {\r\n    // A counter for the browser's launch retries\r\n    let tryCount = 0;\r\n    const openBrowser = async () => {\r\n      try {\r\n        log(\r\n          3,\r\n          `[browser] Attempting to launch and get a browser instance (try ${++tryCount}).`\r\n        );\r\n\r\n        // Launch the browser\r\n        browser = await puppeteer.launch(launchOptions);\r\n      } catch (error) {\r\n        logWithStack(\r\n          1,\r\n          error,\r\n          '[browser] Failed to launch a browser instance.'\r\n        );\r\n\r\n        // Retry to launch browser until reaching max attempts\r\n        if (tryCount < 25) {\r\n          log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n          // Wait for a 4 seconds before trying again\r\n          await new Promise((response) => setTimeout(response, 4000));\r\n          await openBrowser();\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    };\r\n\r\n    try {\r\n      // Try to open a browser\r\n      await openBrowser();\r\n\r\n      // Shell mode inform\r\n      if (launchOptions.headless === 'shell') {\r\n        log(3, `[browser] Launched browser in shell mode.`);\r\n      }\r\n\r\n      // Debug mode inform\r\n      if (enabledDebug) {\r\n        log(3, `[browser] Launched browser in debug mode.`);\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        '[browser] Maximum retries to open a browser instance reached.',\r\n        500\r\n      ).setError(error);\r\n    }\r\n\r\n    // No correct browser\r\n    if (!browser) {\r\n      throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n    }\r\n  }\r\n\r\n  // Return a browser instance\r\n  return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n  // Close the browser when connected\r\n  if (browser && browser.connected) {\r\n    await browser.close();\r\n  }\r\n  browser = null;\r\n  log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n  // Error in case of no connected browser\r\n  if (!browser || !browser.connected) {\r\n    throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n  }\r\n\r\n  // Create a page\r\n  poolResource.page = await browser.newPage();\r\n\r\n  // Disable cache\r\n  await poolResource.page.setCacheEnabled(false);\r\n\r\n  // Set the content\r\n  await _setPageContent(poolResource.page);\r\n\r\n  // Set page events\r\n  _setPageEvents(poolResource.page);\r\n\r\n  // Check if the page is correctly created\r\n  if (!poolResource.page || poolResource.page.isClosed()) {\r\n    throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If `true`, navigates to `about:blank` and resets content\r\n * and scripts. If `false`, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise<boolean>} A Promise that resolves to `true` when page\r\n * is correctly cleared and `false` when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n  try {\r\n    if (poolResource.page && !poolResource.page.isClosed()) {\r\n      if (hardReset) {\r\n        // Navigate to `about:blank`\r\n        await poolResource.page.goto('about:blank', {\r\n          waitUntil: 'domcontentloaded'\r\n        });\r\n\r\n        // Set the content and and scripts again\r\n        await _setPageContent(poolResource.page);\r\n      } else {\r\n        // Clear body content\r\n        await poolResource.page.evaluate(() => {\r\n          document.body.innerHTML =\r\n            '<div id=\"chart-container\"><div id=\"container\"></div></div>';\r\n        });\r\n      }\r\n      return true;\r\n    }\r\n  } catch (error) {\r\n    logWithStack(\r\n      2,\r\n      error,\r\n      `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n    );\r\n\r\n    // Set the `workLimit` to exceeded in order to recreate the resource\r\n    poolResource.workCount = getOptions().pool.workLimit + 1;\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<Array<Object>>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n  // Injected resources array\r\n  const injectedResources = [];\r\n\r\n  // Use the content of the `resources`\r\n  const resources = customLogicOptions.resources;\r\n  if (resources) {\r\n    const injectedJs = [];\r\n\r\n    // Load custom JS code\r\n    if (resources.js) {\r\n      injectedJs.push({\r\n        content: resources.js\r\n      });\r\n    }\r\n\r\n    // Load scripts from all custom files\r\n    if (resources.files) {\r\n      for (const file of resources.files) {\r\n        const isLocal = file.startsWith('http') ? false : true;\r\n\r\n        // Add each custom script from resources' files\r\n        injectedJs.push(\r\n          isLocal\r\n            ? {\r\n                content: readFileSync(getAbsolutePath(file), 'utf8')\r\n              }\r\n            : {\r\n                url: file\r\n              }\r\n        );\r\n      }\r\n    }\r\n\r\n    // The actual injection of collected scripts\r\n    for (const jsResource of injectedJs) {\r\n      try {\r\n        injectedResources.push(await page.addScriptTag(jsResource));\r\n      } catch (error) {\r\n        logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n      }\r\n    }\r\n    injectedJs.length = 0;\r\n\r\n    // Load CSS\r\n    const injectedCss = [];\r\n    if (resources.css) {\r\n      const cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n      if (cssImports) {\r\n        // Handle css section\r\n        for (let cssImportPath of cssImports) {\r\n          if (cssImportPath) {\r\n            cssImportPath = cssImportPath\r\n              .replace('url(', '')\r\n              .replace('@import', '')\r\n              .replace(/\"/g, '')\r\n              .replace(/'/g, '')\r\n              .replace(/;/, '')\r\n              .replace(/\\)/g, '')\r\n              .trim();\r\n\r\n            // Add each custom css from resources\r\n            if (cssImportPath.startsWith('http')) {\r\n              injectedCss.push({\r\n                url: cssImportPath\r\n              });\r\n            } else if (customLogicOptions.allowFileResources) {\r\n              injectedCss.push({\r\n                path: getAbsolutePath(cssImportPath)\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // The rest of the CSS section will be content by now\r\n      injectedCss.push({\r\n        content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n      });\r\n\r\n      // The actual injection of collected CSS\r\n      for (const cssResource of injectedCss) {\r\n        try {\r\n          injectedResources.push(await page.addStyleTag(cssResource));\r\n        } catch (error) {\r\n          logWithStack(\r\n            2,\r\n            error,\r\n            `[browser] The CSS resource cannot be loaded.`\r\n          );\r\n        }\r\n      }\r\n      injectedCss.length = 0;\r\n    }\r\n  }\r\n  return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array<Object>} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n  try {\r\n    for (const resource of injectedResources) {\r\n      await resource.dispose();\r\n    }\r\n\r\n    // Destroy old charts after export is done and reset all CSS and script tags\r\n    await page.evaluate(() => {\r\n      // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n      if (typeof Highcharts !== 'undefined') {\r\n        // eslint-disable-next-line no-undef\r\n        const oldCharts = Highcharts.charts;\r\n\r\n        // Check in any already existing charts\r\n        if (Array.isArray(oldCharts) && oldCharts.length) {\r\n          // Destroy old charts\r\n          for (const oldChart of oldCharts) {\r\n            oldChart && oldChart.destroy();\r\n            // eslint-disable-next-line no-undef\r\n            Highcharts.charts.shift();\r\n          }\r\n        }\r\n      }\r\n\r\n      // eslint-disable-next-line no-undef\r\n      const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n      // eslint-disable-next-line no-undef\r\n      const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n      // eslint-disable-next-line no-undef\r\n      const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n      // Remove tags\r\n      for (const element of [\r\n        ...scriptsToRemove,\r\n        ...stylesToRemove,\r\n        ...linksToRemove\r\n      ]) {\r\n        element.remove();\r\n      }\r\n    });\r\n  } catch (error) {\r\n    logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n  }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n  // Set the initial page content\r\n  await page.setContent(pageTemplate, { waitUntil: 'domcontentloaded' });\r\n\r\n  // Add all registered Higcharts scripts, quite demanding\r\n  await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n  // Set the initial `animObject` for Highcharts\r\n  await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n  // Get `debug` options\r\n  const { debug } = getOptions();\r\n\r\n  // Set the `pageerror` listener\r\n  page.on('pageerror', async () => {\r\n    // It would seem like this may fire at the same time or shortly before\r\n    // a page is closed.\r\n    if (page.isClosed()) {\r\n      return;\r\n    }\r\n  });\r\n\r\n  // Set the `console` listener, if needed\r\n  if (debug.enable && debug.listenToConsole) {\r\n    page.on('console', (message) => {\r\n      console.log(`[debug] ${message.text()}`);\r\n    });\r\n  }\r\n}\r\n\r\nexport default {\r\n  getBrowser,\r\n  createBrowser,\r\n  closeBrowser,\r\n  newPage,\r\n  clearPage,\r\n  addPageResources,\r\n  clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n  margin: 0;\r\n  padding: 0;\r\n  box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n  display: none;\r\n  height: 0;\r\n}\r\n\r\n#chart-container {\r\n  box-sizing: border-box;\r\n  margin: 0;\r\n  overflow: auto;\r\n  font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n  margin-top: 0 !important;\r\n  margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n<!DOCTYPE html>\r\n<html lang='en-US'>\r\n  <head>\r\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\r\n    <title>Highcharts Export</title>\r\n  </head>\r\n  <style>\r\n    ${cssTemplate()}\r\n  </style>\r\n  <body>\r\n    <div id=\"chart-container\">\r\n      ${svg}\r\n    </div>\r\n  </body>\r\n</html>\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n  // Injected resources array (additional JS and CSS)\r\n  const injectedResources = [];\r\n\r\n  try {\r\n    let isSVG = false;\r\n\r\n    // Decide on the export method\r\n    if (exportOptions.svg) {\r\n      log(4, '[export] Treating as SVG input.');\r\n\r\n      // If the `type` is also SVG, return the input\r\n      if (exportOptions.type === 'svg') {\r\n        return exportOptions.svg;\r\n      }\r\n\r\n      // Mark as SVG export for the later size corrections\r\n      isSVG = true;\r\n\r\n      // SVG export\r\n      await page.setContent(svgTemplate(exportOptions.svg), {\r\n        waitUntil: 'domcontentloaded'\r\n      });\r\n    } else {\r\n      log(4, '[export] Treating as JSON config.');\r\n\r\n      // Options export\r\n      await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n    }\r\n\r\n    // Keeps track of all resources added on the page with addXXXTag. etc\r\n    // It's VITAL that all added resources ends up here so we can clear things\r\n    // out when doing a new export in the same page!\r\n    injectedResources.push(\r\n      ...(await addPageResources(page, customLogicOptions))\r\n    );\r\n\r\n    // Get the real chart size and set the zoom accordingly\r\n    const size = await _getChartSize(page, isSVG, exportOptions.scale);\r\n\r\n    // Get the clip region for the page\r\n    const { x, y } = await _getClipRegion(page);\r\n\r\n    // Set final `height` for viewport\r\n    const viewportHeight = Math.abs(\r\n      Math.ceil(size.chartHeight || exportOptions.height)\r\n    );\r\n\r\n    // Set final `width` for viewport\r\n    const viewportWidth = Math.abs(\r\n      Math.ceil(size.chartWidth || exportOptions.width)\r\n    );\r\n\r\n    // Set the final viewport now that we have the real height\r\n    await page.setViewport({\r\n      height: viewportHeight,\r\n      width: viewportWidth,\r\n      deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n    });\r\n\r\n    let result;\r\n    // Rasterization process\r\n    switch (exportOptions.type) {\r\n      case 'svg':\r\n        result = await _createSVG(page);\r\n        break;\r\n      case 'png':\r\n      case 'jpeg':\r\n        result = await _createImage(\r\n          page,\r\n          exportOptions.type,\r\n          {\r\n            width: viewportWidth,\r\n            height: viewportHeight,\r\n            x,\r\n            y\r\n          },\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      case 'pdf':\r\n        result = await _createPDF(\r\n          page,\r\n          viewportHeight,\r\n          viewportWidth,\r\n          exportOptions.rasterizationTimeout\r\n        );\r\n        break;\r\n      default:\r\n        throw new ExportError(\r\n          `[export] Unsupported output format: ${exportOptions.type}.`,\r\n          400\r\n        );\r\n    }\r\n\r\n    // Clear previously injected JS and CSS resources\r\n    await clearPageResources(page, injectedResources);\r\n    return result;\r\n  } catch (error) {\r\n    await clearPageResources(page, injectedResources);\r\n    return error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n  return page.$eval('#chart-container', (element) => {\r\n    const { x, y, width, height } = element.getBoundingClientRect();\r\n    return {\r\n      x,\r\n      y,\r\n      width,\r\n      height: Math.trunc(height > 1 ? height : 500)\r\n    };\r\n  });\r\n}\r\n\r\n/**\r\n * Retrieves the real chart dimensions from a Puppeteer page. The function\r\n * behaves differently based on whether the export type is SVG or another\r\n * format.\r\n *\r\n * @async\r\n * @function _getChartSize\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {boolean} isSVG - Determines whether the chart being processed\r\n * is an SVG or another format.\r\n * @param {number} scale - The scale factor to be applied to the chart\r\n * dimensions.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to an object containing\r\n * the actual height and width of the chart after scaling.\r\n */\r\nasync function _getChartSize(page, isSVG, scale) {\r\n  // Trigger appropriate function based on the `isSvg` flag to get chart size\r\n  return isSVG\r\n    ? await page.evaluate((scale) => {\r\n        const svgElement = document.querySelector(\r\n          '#chart-container svg:first-of-type'\r\n        );\r\n\r\n        // Get the values correctly scaled\r\n        const chartHeight = svgElement.height.baseVal.value * scale;\r\n        const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n        // In case of SVG the zoom must be set directly for body as scale\r\n        // eslint-disable-next-line no-undef\r\n        document.body.style.zoom = scale;\r\n\r\n        // Set the margin to 0px\r\n        // eslint-disable-next-line no-undef\r\n        document.body.style.margin = '0px';\r\n\r\n        return {\r\n          chartHeight,\r\n          chartWidth\r\n        };\r\n      }, parseFloat(scale))\r\n    : await page.evaluate(() => {\r\n        // eslint-disable-next-line no-undef\r\n        const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n        // No need for such scale manipulation in case of other types\r\n        // of exports. Reset the zoom for other exports than to SVGs\r\n        // eslint-disable-next-line no-undef\r\n        document.body.style.zoom = 1;\r\n\r\n        return {\r\n          chartHeight,\r\n          chartWidth\r\n        };\r\n      });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise<string>} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n  return page.$eval(\r\n    '#container svg:first-of-type',\r\n    (element) => element.outerHTML\r\n  );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n  return Promise.race([\r\n    page.screenshot({\r\n      type,\r\n      clip,\r\n      encoding: 'base64',\r\n      fullPage: false,\r\n      optimizeForSpeed: true,\r\n      captureBeyondViewport: true,\r\n      ...(type !== 'png' ? { quality: 80 } : {}),\r\n      // Always render on a transparent page if the expected type format is PNG\r\n      omitBackground: type == 'png' // #447, #463\r\n    }),\r\n    new Promise((_resolve, reject) =>\r\n      setTimeout(\r\n        () => reject(new ExportError('Rasterization timeout', 408)),\r\n        rasterizationTimeout || 1500\r\n      )\r\n    )\r\n  ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise<Buffer>} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n  await page.emulateMediaType('screen');\r\n  return page.pdf({\r\n    // This will remove an extra empty page in PDF exports\r\n    height: height + 1,\r\n    width,\r\n    encoding: 'base64',\r\n    timeout: rasterizationTimeout || 1500\r\n  });\r\n}\r\n\r\nexport default {\r\n  puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n  exportsAttempted: 0,\r\n  exportsPerformed: 0,\r\n  exportsDropped: 0,\r\n  exportsFromSvg: 0,\r\n  exportsFromOptions: 0,\r\n  exportsFromSvgAttempts: 0,\r\n  exportsFromOptionsAttempts: 0,\r\n  timeSpent: 0,\r\n  timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array<string>} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n  // Create a browser instance with the puppeteer arguments\r\n  await createBrowser(puppeteerArgs);\r\n\r\n  try {\r\n    log(\r\n      3,\r\n      `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n    );\r\n\r\n    if (pool) {\r\n      log(\r\n        4,\r\n        '[pool] Already initialized, please kill it before creating a new one.'\r\n      );\r\n      return;\r\n    }\r\n\r\n    // Keep an eye on a correct min and max workers number\r\n    if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n      poolOptions.minWorkers = poolOptions.maxWorkers;\r\n    }\r\n\r\n    // Create a pool along with a minimal number of resources\r\n    pool = new Pool({\r\n      // Get the `create`, `validate`, and `destroy` functions\r\n      ..._factory(poolOptions),\r\n      min: poolOptions.minWorkers,\r\n      max: poolOptions.maxWorkers,\r\n      acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n      createTimeoutMillis: poolOptions.createTimeout,\r\n      destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n      idleTimeoutMillis: poolOptions.idleTimeout,\r\n      createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n      reapIntervalMillis: poolOptions.reaperInterval,\r\n      propagateCreateError: false\r\n    });\r\n\r\n    // Set events\r\n    pool.on('release', async (resource) => {\r\n      // Clear page\r\n      const clearStatus = await clearPage(resource, false);\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n      );\r\n    });\r\n\r\n    pool.on('destroySuccess', (_eventId, resource) => {\r\n      log(\r\n        4,\r\n        `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n      );\r\n      resource.page = null;\r\n    });\r\n\r\n    const initialResources = [];\r\n    // Create an initial number of resources\r\n    for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n      try {\r\n        const resource = await pool.acquire().promise;\r\n        initialResources.push(resource);\r\n      } catch (error) {\r\n        logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n      }\r\n    }\r\n\r\n    // Release the initial number of resources back to the pool\r\n    initialResources.forEach((resource) => {\r\n      pool.release(resource);\r\n    });\r\n\r\n    log(\r\n      3,\r\n      `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n    );\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[pool] Could not configure and create the pool of workers.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n  log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n  // If still alive, destroy the pool of pages before closing a browser\r\n  if (pool) {\r\n    // Free up not released workers\r\n    for (const worker of pool.used) {\r\n      pool.release(worker.resource);\r\n    }\r\n\r\n    // Destroy the pool if it is still available\r\n    if (!pool.destroyed) {\r\n      await pool.destroy();\r\n      log(4, '[pool] Destroyed the pool of resources.');\r\n    }\r\n    pool = null;\r\n  }\r\n\r\n  // Close the browser instance\r\n  await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<Object>} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n  let workerHandle;\r\n\r\n  try {\r\n    log(4, '[pool] Work received, starting to process.');\r\n\r\n    // An export attempt counted\r\n    ++poolStats.exportsAttempted;\r\n\r\n    // Display the pool information if needed\r\n    if (options.pool.benchmarking) {\r\n      _getPoolInfo();\r\n    }\r\n\r\n    // Throw an error in case of lacking the pool instance\r\n    if (!pool) {\r\n      throw new ExportError(\r\n        '[pool] Work received, but pool has not been started.',\r\n        500\r\n      );\r\n    }\r\n\r\n    // The acquire counter\r\n    const acquireCounter = measureTime();\r\n\r\n    // Try to acquire the worker along with the id, works count and page\r\n    try {\r\n      log(4, '[pool] Acquiring a worker handle.');\r\n\r\n      // Acquire a pool resource\r\n      workerHandle = await pool.acquire().promise;\r\n\r\n      // Check the page acquire time\r\n      if (options.server.benchmarking) {\r\n        log(\r\n          5,\r\n          `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n          `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n        );\r\n      }\r\n    } catch (error) {\r\n      throw new ExportError(\r\n        `[pool] ${\r\n          options.requestId ? `Request [${options.requestId}] - ` : ''\r\n        }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n        400\r\n      ).setError(error);\r\n    }\r\n    log(4, '[pool] Acquired a worker handle.');\r\n\r\n    if (!workerHandle.page) {\r\n      // Set the `workLimit` to exceeded in order to recreate the resource\r\n      workerHandle.workCount = options.pool.workLimit + 1;\r\n      throw new ExportError(\r\n        '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n        400\r\n      );\r\n    }\r\n\r\n    log(\r\n      4,\r\n      `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n    );\r\n\r\n    // Start measuring export time\r\n    const exportCounter = measureTime();\r\n\r\n    // Perform an export on a puppeteer level\r\n    const exportResult = await puppeteerExport(\r\n      workerHandle.page,\r\n      options.export,\r\n      options.customLogic\r\n    );\r\n\r\n    // Check if it's an error\r\n    if (exportResult instanceof Error) {\r\n      // NOTE:\r\n      // If there's a rasterization timeout, we want need to flush the page.\r\n      // This is because the page may be in a state where it's waiting for\r\n      // the screenshot to finish even though the timeout has occured.\r\n      // Which of course causes a lot of issues with the event system,\r\n      // and page consistency.\r\n      //\r\n      // Only `page.screenshot` will throw this, timeouts for PDF's are\r\n      // handled by the `page.pdf` function itself.\r\n      //\r\n      // ...yes, this is ugly.\r\n      if (exportResult.message === 'Rasterization timeout') {\r\n        // Set the `workLimit` to exceeded in order to recreate the resource\r\n        workerHandle.workCount = options.pool.workLimit + 1;\r\n        workerHandle.page = null;\r\n      }\r\n\r\n      if (\r\n        exportResult.name === 'TimeoutError' ||\r\n        exportResult.message === 'Rasterization timeout'\r\n      ) {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n        ).setError(exportResult);\r\n      } else {\r\n        throw new ExportError(\r\n          `[pool] ${\r\n            options.requestId ? `Request [${options.requestId}] - ` : ''\r\n          }Error encountered during export: ${exportCounter()}ms.`\r\n        ).setError(exportResult);\r\n      }\r\n    }\r\n\r\n    // Check the Puppeteer export time\r\n    if (options.server.benchmarking) {\r\n      log(\r\n        5,\r\n        `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n        `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n      );\r\n    }\r\n\r\n    // Release the resource back to the pool\r\n    pool.release(workerHandle);\r\n\r\n    // Update statistics\r\n    poolStats.timeSpent += exportCounter();\r\n    poolStats.timeSpentAverage =\r\n      poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n    log(4, `[pool] Work completed in ${exportCounter()}ms.`);\r\n\r\n    // Otherwise return an object with the result and options\r\n    return {\r\n      result: exportResult,\r\n      options\r\n    };\r\n  } catch (error) {\r\n    ++poolStats.exportsDropped;\r\n\r\n    // Try to release the worker, if it exists\r\n    if (workerHandle) {\r\n      pool.release(workerHandle);\r\n    }\r\n\r\n    throw error;\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or `null`\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n  return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n  return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n  return {\r\n    min: pool.min,\r\n    max: pool.max,\r\n    used: pool.numUsed(),\r\n    available: pool.numFree(),\r\n    allCreated: pool.numUsed() + pool.numFree(),\r\n    pendingAcquires: pool.numPendingAcquires(),\r\n    pendingCreates: pool.numPendingCreates(),\r\n    pendingValidations: pool.numPendingValidations(),\r\n    pendingDestroys: pool.pendingDestroys.length,\r\n    absoluteAll:\r\n      pool.numUsed() +\r\n      pool.numFree() +\r\n      pool.numPendingAcquires() +\r\n      pool.numPendingCreates() +\r\n      pool.numPendingValidations() +\r\n      pool.pendingDestroys.length\r\n  };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function _getPoolInfo\r\n */\r\nfunction _getPoolInfo() {\r\n  const {\r\n    min,\r\n    max,\r\n    used,\r\n    available,\r\n    allCreated,\r\n    pendingAcquires,\r\n    pendingCreates,\r\n    pendingValidations,\r\n    pendingDestroys,\r\n    absoluteAll\r\n  } = getPoolInfoJSON();\r\n\r\n  log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n  log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n  log(5, `[pool] The number of used resources: ${used}.`);\r\n  log(5, `[pool] The number of free resources: ${available}.`);\r\n  log(\r\n    5,\r\n    `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n  );\r\n  log(\r\n    5,\r\n    `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n  );\r\n  log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`, `destroy`\r\n * functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n  return {\r\n    /**\r\n     * Creates a new worker page for the export pool.\r\n     *\r\n     * @async\r\n     * @function create\r\n     *\r\n     * @returns {Promise<Object>} A Promise that resolves to an object\r\n     * containing the worker ID, a reference to the browser page, and initial\r\n     * work count.\r\n     *\r\n     * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n     * the creation of the new page.\r\n     */\r\n    create: async () => {\r\n      // Init the resource with unique id and work count\r\n      const poolResource = {\r\n        id: uuid(),\r\n        // Try to distribute the initial work count\r\n        workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n      };\r\n\r\n      try {\r\n        // Start measuring a page creation time\r\n        const startDate = getNewDateTime();\r\n\r\n        // Create a new page\r\n        await newPage(poolResource);\r\n\r\n        // Measure the time of full creation and configuration of a page\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n            getNewDateTime() - startDate\r\n          }ms.`\r\n        );\r\n\r\n        // Return ready pool resource\r\n        return poolResource;\r\n      } catch (error) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n        );\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    /**\r\n     * Validates a worker page in the export pool, checking if it has exceeded\r\n     * the work limit.\r\n     *\r\n     * @async\r\n     * @function validate\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     *\r\n     * @returns {Promise<boolean>} A Promise that resolves to true if the worker\r\n     * is valid and within the work limit; otherwise, to false.\r\n     */\r\n    validate: async (poolResource) => {\r\n      // NOTE:\r\n      // In certain cases acquiring throws a `TargetCloseError`, which may\r\n      // be caused by two things:\r\n      // - The page is closed and attempted to be reused.\r\n      // - Lost contact with the browser.\r\n      //\r\n      // What we're seeing in logs is that successive exports typically\r\n      // succeeds, and the server recovers, indicating that it's likely\r\n      // the first case. This is an attempt at allievating the issue by\r\n      // simply not validating the worker if the page is null or closed.\r\n      //\r\n      // The actual result from when this happened, was that a worker would\r\n      // be completely locked, stopping it from being acquired until\r\n      // its work count reached the limit.\r\n\r\n      // Check if the `page` is valid\r\n      if (!poolResource.page) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `page` is closed\r\n      if (poolResource.page.isClosed()) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `mainFrame` is detached\r\n      if (poolResource.page.mainFrame().detached) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // Check if the `workLimit` is exceeded\r\n      if (\r\n        poolOptions.workLimit &&\r\n        ++poolResource.workCount > poolOptions.workLimit\r\n      ) {\r\n        log(\r\n          3,\r\n          `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n        );\r\n        return false;\r\n      }\r\n\r\n      // The `poolResource` is validated\r\n      return true;\r\n    },\r\n\r\n    /**\r\n     * Destroys a worker entry in the export pool, closing its associated page.\r\n     *\r\n     * @async\r\n     * @function destroy\r\n     *\r\n     * @param {Object} poolResource - The handle to the worker, containing\r\n     * the worker's ID, a reference to the browser page, and work count.\r\n     */\r\n    destroy: async (poolResource) => {\r\n      log(\r\n        3,\r\n        `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n      );\r\n\r\n      if (poolResource.page && !poolResource.page.isClosed()) {\r\n        try {\r\n          // Remove all attached event listeners from the resource\r\n          poolResource.page.removeAllListeners('pageerror');\r\n          poolResource.page.removeAllListeners('console');\r\n          poolResource.page.removeAllListeners('framedetached');\r\n\r\n          // We need to wait around for this\r\n          await poolResource.page.close();\r\n        } catch (error) {\r\n          log(\r\n            3,\r\n            `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n          );\r\n          throw error;\r\n        }\r\n      }\r\n    }\r\n  };\r\n}\r\n\r\nexport default {\r\n  initPool,\r\n  killPool,\r\n  postWork,\r\n  getPool,\r\n  getPoolStats,\r\n  getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing <script> tags. This function uses\r\n * a regular expression to find and remove all occurrences of <script></script>\r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n  // Get the virtual DOM\r\n  const window = new JSDOM('').window;\r\n\r\n  // Create a purifying instance\r\n  const purify = DOMPurify(window);\r\n\r\n  // Return sanitized input, allowing for the `foreignObject` elements\r\n  return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n  sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions that prepare for the exporting\r\n * charts into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { isAllowedConfig, updateOptions, validateOption } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport { getAbsolutePath, getBase64, isObject, roundNumber } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export) {\r\n    // Perform an export\r\n    await startExport(\r\n      { export: options.export, customLogic: options.customLogic },\r\n      async (error, data) => {\r\n        // Exit process when error exists\r\n        if (error) {\r\n          throw error;\r\n        }\r\n\r\n        // Get the `b64`, `outfile`, and `type` for a chart\r\n        const { b64, outfile, type } = data.options.export;\r\n\r\n        // Save the result\r\n        try {\r\n          if (b64) {\r\n            // As a Base64 string to a txt file\r\n            writeFileSync(\r\n              `${outfile.split('.').shift() || 'chart'}.txt`,\r\n              getBase64(data.result, type)\r\n            );\r\n          } else {\r\n            // As a correct image format\r\n            writeFileSync(\r\n              outfile || `chart.${type}`,\r\n              type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n            );\r\n          }\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            '[chart] Error while saving a chart.',\r\n            500\r\n          ).setError(error);\r\n        }\r\n\r\n        // Kill pool and close browser after finishing single export\r\n        await killPool();\r\n      }\r\n    );\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n  // Check if the export makes sense\r\n  if (options && options.export && options.export.batch) {\r\n    // An array for collecting batch exports\r\n    const batchFunctions = [];\r\n\r\n    // Split and pair the `batch` arguments\r\n    for (let pair of options.export.batch.split(';') || []) {\r\n      pair = pair.split('=');\r\n      if (pair.length === 2) {\r\n        batchFunctions.push(\r\n          startExport(\r\n            {\r\n              export: {\r\n                ...options.export,\r\n                infile: pair[0],\r\n                outfile: pair[1]\r\n              },\r\n              customLogic: options.customLogic\r\n            },\r\n            (error, data) => {\r\n              // Exit process when error exists\r\n              if (error) {\r\n                throw error;\r\n              }\r\n\r\n              // Get the `b64`, `outfile`, and `type` for a chart\r\n              const { b64, outfile, type } = data.options.export;\r\n\r\n              // Save the result\r\n              try {\r\n                if (b64) {\r\n                  // As a Base64 string to a txt file\r\n                  writeFileSync(\r\n                    `${outfile.split('.').shift() || 'chart'}.txt`,\r\n                    getBase64(data.result, type)\r\n                  );\r\n                } else {\r\n                  // As a correct image format\r\n                  writeFileSync(\r\n                    outfile,\r\n                    type !== 'svg'\r\n                      ? Buffer.from(data.result, 'base64')\r\n                      : data.result\r\n                  );\r\n                }\r\n              } catch (error) {\r\n                throw new ExportError(\r\n                  '[chart] Error while saving a chart.',\r\n                  500\r\n                ).setError(error);\r\n              }\r\n            }\r\n          )\r\n        );\r\n      } else {\r\n        log(2, '[chart] No correct pair found for the batch export.');\r\n      }\r\n    }\r\n\r\n    // Await all exports are done\r\n    const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n    // Kill pool and close browser after finishing batch export\r\n    await killPool();\r\n\r\n    // Log errors if found\r\n    batchResults.forEach((result, index) => {\r\n      // Log the error with stack about the specific batch export\r\n      if (result.reason) {\r\n        logWithStack(\r\n          1,\r\n          result.reason,\r\n          `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n        );\r\n      }\r\n    });\r\n  } else {\r\n    throw new ExportError(\r\n      '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n      400\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise<void>} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n  try {\r\n    // Check if provided options are in an object\r\n    if (!isObject(imageOptions)) {\r\n      throw new ExportError(\r\n        '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n        400\r\n      );\r\n    }\r\n\r\n    // Merge additional options to the copy of the instance options\r\n    const options = updateOptions(\r\n      {\r\n        export: imageOptions.export,\r\n        customLogic: imageOptions.customLogic\r\n      },\r\n      true\r\n    );\r\n\r\n    // Get the `export` options\r\n    const exportOptions = options.export;\r\n\r\n    // Starting exporting process message\r\n    log(4, '[chart] Starting the exporting process.');\r\n\r\n    // Export using options from the file as an input\r\n    if (exportOptions.infile !== null) {\r\n      log(4, '[chart] Attempting to export from a file input.');\r\n\r\n      let fileContent;\r\n      try {\r\n        // Try to read the file to get the string representation\r\n        fileContent = readFileSync(\r\n          getAbsolutePath(exportOptions.infile),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        throw new ExportError(\r\n          '[chart] Error loading content from a file input.',\r\n          400\r\n        ).setError(error);\r\n      }\r\n\r\n      // Check the file's extension\r\n      if (exportOptions.infile.endsWith('.svg')) {\r\n        // Set to the `svg` option\r\n        exportOptions.svg = validateOption('svg', fileContent);\r\n      } else if (exportOptions.infile.endsWith('.json')) {\r\n        // Set to the `instr` option\r\n        exportOptions.instr = validateOption('instr', fileContent);\r\n      } else {\r\n        throw new ExportError(\r\n          '[chart] Incorrect value of the `infile` option.',\r\n          400\r\n        );\r\n      }\r\n    }\r\n\r\n    // Export using SVG as an input\r\n    if (exportOptions.svg !== null) {\r\n      log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n      // SVG exports attempts counter\r\n      ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n      // Export from an SVG string\r\n      const result = await _exportFromSvg(\r\n        sanitize(exportOptions.svg), // #209\r\n        options\r\n      );\r\n\r\n      // SVG exports counter\r\n      ++getPoolStats().exportsFromSvg;\r\n\r\n      // Pass SVG export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // Export using options as an input\r\n    if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n      log(4, '[chart] Attempting to export from options input.');\r\n\r\n      // Options exports attempts counter\r\n      ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n      // Export from options\r\n      const result = await _exportFromOptions(\r\n        exportOptions.instr || exportOptions.options,\r\n        options\r\n      );\r\n\r\n      // Options exports counter\r\n      ++getPoolStats().exportsFromOptions;\r\n\r\n      // Pass options export result to the end callback\r\n      return endCallback(null, result);\r\n    }\r\n\r\n    // No input specified, pass an error message to the callback\r\n    return endCallback(\r\n      new ExportError(\r\n        `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n        400\r\n      )\r\n    );\r\n  } catch (error) {\r\n    return endCallback(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n  return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n  allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n  // Check if it is SVG\r\n  if (\r\n    typeof inputToExport === 'string' &&\r\n    (inputToExport.indexOf('<svg') >= 0 || inputToExport.indexOf('<?xml') >= 0)\r\n  ) {\r\n    log(4, '[chart] Parsing input as SVG.');\r\n\r\n    // Set the export input as SVG\r\n    options.export.svg = inputToExport;\r\n\r\n    // Reset the rest of the export input options\r\n    options.export.options = null;\r\n    options.export.instr = null;\r\n\r\n    // Call the function with an SVG string as an export input\r\n    return _prepareExport(options);\r\n  } else {\r\n    throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n  }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n  log(4, '[chart] Parsing input from options.');\r\n\r\n  // Try to check, validate and parse to stringified options\r\n  const stringifiedOptions = isAllowedConfig(\r\n    inputToExport,\r\n    true,\r\n    options.customLogic.allowCodeExecution\r\n  );\r\n\r\n  // Check if a correct stringified options\r\n  if (\r\n    stringifiedOptions === null ||\r\n    typeof stringifiedOptions !== 'string' ||\r\n    !stringifiedOptions.startsWith('{') ||\r\n    !stringifiedOptions.endsWith('}')\r\n  ) {\r\n    throw new ExportError(\r\n      '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n      403\r\n    );\r\n  }\r\n\r\n  // Set the export input as a stringified chart options\r\n  options.export.instr = stringifiedOptions;\r\n\r\n  // Reset the rest of the export input options\r\n  options.export.options = null;\r\n  options.export.svg = null;\r\n\r\n  // Call the function with a stringified chart options\r\n  return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise<unknown>} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n  // Get the `export` and `customLogic` options\r\n  const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n  // Prepare the `constr` option\r\n  exportOptions.constr = _fixConstr(exportOptions.constr);\r\n\r\n  // Prepare the `type` option\r\n  exportOptions.type = _fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n  // Prepare the `outfile` option\r\n  exportOptions.outfile = _fixOutfile(\r\n    exportOptions.type,\r\n    exportOptions.outfile\r\n  );\r\n\r\n  // Notify about the custom logic usage status\r\n  log(\r\n    3,\r\n    `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n  );\r\n\r\n  // Prepare the `customCode`, `callback`, and `resources` options\r\n  _handleCustomLogic(customLogicOptions);\r\n\r\n  // Prepare the `globalOptions` and `themeOptions` options\r\n  _handleGlobalAndTheme(exportOptions, customLogicOptions);\r\n\r\n  // Prepare the `height`, `width`, and `scale` options\r\n  _handleSize(exportOptions);\r\n\r\n  // Check if the image options object does not exceed the size limit\r\n  _checkDataSize({ export: exportOptions, customLogic: customLogicOptions });\r\n\r\n  // Post the work to the pool\r\n  return postWork(options);\r\n}\r\n\r\n/**\r\n * Handles adjusting the constructor name by transforming and normalizing\r\n * it based on common chart types.\r\n *\r\n * @function _fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be adjusted.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixConstr(constr) {\r\n  try {\r\n    // Fix the constructor by lowering casing\r\n    const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n    // Handle the case where the result is just 'Chart'\r\n    if (fixedConstr === 'Chart') {\r\n      fixedConstr.toLowerCase();\r\n    }\r\n\r\n    // Return the corrected constructor, otherwise default to 'chart'\r\n    return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n      fixedConstr\r\n    )\r\n      ? fixedConstr\r\n      : 'chart';\r\n  } catch {\r\n    // Default to 'chart' in case of any error\r\n    return 'chart';\r\n  }\r\n}\r\n\r\n/**\r\n * Handles fixing the outfile based on provided type.\r\n *\r\n * @function _fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile, or 'chart.png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixOutfile(type, outfile) {\r\n  // Get the file name from the `outfile` option\r\n  const fileName = getAbsolutePath(outfile || 'chart')\r\n    .split('.')\r\n    .shift();\r\n\r\n  // Return a correct outfile\r\n  return `${fileName}.${type || 'png'}`;\r\n}\r\n\r\n/**\r\n * Handles fixing the export type based on MIME types and file extensions.\r\n *\r\n * @function _fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type, or 'png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixType(type, outfile = null) {\r\n  // MIME types\r\n  const mimeTypes = {\r\n    'image/png': 'png',\r\n    'image/jpeg': 'jpeg',\r\n    'application/pdf': 'pdf',\r\n    'image/svg+xml': 'svg'\r\n  };\r\n\r\n  // Get formats\r\n  const formats = Object.values(mimeTypes);\r\n\r\n  // Check if type and outfile's extensions are the same\r\n  if (outfile) {\r\n    const outType = outfile.split('.').pop();\r\n\r\n    // Support the JPG type\r\n    if (outType === 'jpg') {\r\n      type = 'jpeg';\r\n    } else if (formats.includes(outType) && type !== outType) {\r\n      type = outType;\r\n    }\r\n  }\r\n\r\n  // Return a correct type\r\n  return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Handle calculating the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _handleSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n */\r\nfunction _handleSize(exportOptions) {\r\n  // Check the `options` and `instr` for chart and exporting sections\r\n  const { chart: optionsChart, exporting: optionsExporting } =\r\n    isAllowedConfig(exportOptions.instr) || false;\r\n\r\n  // Check the `globalOptions` for chart and exporting sections\r\n  const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n    isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n  // Check the `themeOptions` for chart and exporting sections\r\n  const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n    isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n  // Find the `height` value\r\n  const height =\r\n    exportOptions.height ||\r\n    optionsExporting?.sourceHeight ||\r\n    optionsChart?.height ||\r\n    globalOptionsExporting?.sourceHeight ||\r\n    globalOptionsChart?.height ||\r\n    themeOptionsExporting?.sourceHeight ||\r\n    themeOptionsChart?.height ||\r\n    exportOptions.defaultHeight ||\r\n    400;\r\n\r\n  // Find the `width` value\r\n  const width =\r\n    exportOptions.width ||\r\n    optionsExporting?.sourceWidth ||\r\n    optionsChart?.width ||\r\n    globalOptionsExporting?.sourceWidth ||\r\n    globalOptionsChart?.width ||\r\n    themeOptionsExporting?.sourceWidth ||\r\n    themeOptionsChart?.width ||\r\n    exportOptions.defaultWidth ||\r\n    600;\r\n\r\n  // Find the `scale` value:\r\n  // - Cannot be lower than 0.1\r\n  // - Cannot be higher than 5.0\r\n  // - Must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n  const scale = roundNumber(\r\n    Math.max(\r\n      0.1,\r\n      Math.min(\r\n        exportOptions.scale ||\r\n          optionsExporting?.scale ||\r\n          globalOptionsExporting?.scale ||\r\n          themeOptionsExporting?.scale ||\r\n          exportOptions.defaultScale ||\r\n          1,\r\n        5.0\r\n      )\r\n    ),\r\n    2\r\n  );\r\n\r\n  // Update `height`, `width`, and `scale` information in the `export` options\r\n  exportOptions.height = height;\r\n  exportOptions.width = width;\r\n  exportOptions.scale = scale;\r\n\r\n  // Get rid of potential `px` and `%`\r\n  for (let param of ['height', 'width', 'scale']) {\r\n    if (typeof exportOptions[param] === 'string') {\r\n      exportOptions[param] = +exportOptions[param].replace(/px|%/gi, '');\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions) {\r\n  // In case of allowing code execution\r\n  if (customLogicOptions.allowCodeExecution) {\r\n    // Process the `resources` option\r\n    try {\r\n      // Try to handle resources\r\n      customLogicOptions.resources = _handleResources(\r\n        customLogicOptions.resources,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate option\r\n      customLogicOptions.resources = validateOption(\r\n        'resources',\r\n        customLogicOptions.resources\r\n      );\r\n    } catch (error) {\r\n      log(2, '[chart] The `resources` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.resources = null;\r\n    }\r\n\r\n    // Process the `customCode` option\r\n    try {\r\n      // Try to load custom code and wrap around it in a self invoking function\r\n      customLogicOptions.customCode = _handleCustomCode(\r\n        customLogicOptions.customCode,\r\n        customLogicOptions.allowFileResources\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.customCode = validateOption(\r\n        'customCode',\r\n        customLogicOptions.customCode\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.customCode = null;\r\n    }\r\n\r\n    // Process the `callback` option\r\n    try {\r\n      // Try to load callback function\r\n      customLogicOptions.callback = _handleCustomCode(\r\n        customLogicOptions.callback,\r\n        customLogicOptions.allowFileResources,\r\n        true\r\n      );\r\n\r\n      // Validate the option\r\n      customLogicOptions.callback = validateOption(\r\n        'callback',\r\n        customLogicOptions.callback\r\n      );\r\n    } catch (error) {\r\n      logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n      // In case of an error, set the option with null\r\n      customLogicOptions.callback = null;\r\n    }\r\n\r\n    // Check if there is the `customCode` present\r\n    if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n      log(3, '[chart] No value for the `customCode` option found.');\r\n    }\r\n\r\n    // Check if there is the `callback` present\r\n    if ([null, undefined].includes(customLogicOptions.callback)) {\r\n      log(3, '[chart] No value for the `callback` option found.');\r\n    }\r\n\r\n    // Check if there is the `resources` present\r\n    if ([null, undefined].includes(customLogicOptions.resources)) {\r\n      log(3, '[chart] No value for the `resources` option found.');\r\n    }\r\n  } else {\r\n    // If the `allowCodeExecution` flag is set to false, we should refuse\r\n    // the usage of the `callback`, `resources`, and `customCode` options.\r\n    // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n    if (\r\n      customLogicOptions.callback ||\r\n      customLogicOptions.resources ||\r\n      customLogicOptions.customCode\r\n    ) {\r\n      // Reset all custom code options\r\n      customLogicOptions.callback = null;\r\n      customLogicOptions.resources = null;\r\n      customLogicOptions.customCode = null;\r\n\r\n      // Send a message saying that the exporter does not support these settings\r\n      throw new ExportError(\r\n        `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n        403\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n  resources = null,\r\n  allowFileResources,\r\n  allowCodeExecution\r\n) {\r\n  let handledResources = resources;\r\n\r\n  // If no resources found, try to load the default resources\r\n  if (!handledResources) {\r\n    resources = 'resources.json';\r\n  }\r\n\r\n  // List of allowed sections in the resources JSON\r\n  const allowedProps = ['js', 'css', 'files'];\r\n\r\n  // A flag that decides based to return resources or `null`\r\n  let correctResources = false;\r\n\r\n  // Try to load resources from a file\r\n  if (\r\n    allowFileResources &&\r\n    typeof resources === 'string' &&\r\n    resources.endsWith('.json')\r\n  ) {\r\n    handledResources = isAllowedConfig(\r\n      readFileSync(getAbsolutePath(resources), 'utf8'),\r\n      false,\r\n      allowCodeExecution\r\n    );\r\n  } else {\r\n    // Try to get JSON\r\n    handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n    // Get rid of the files section\r\n    if (handledResources && !allowFileResources) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Filter from unnecessary properties\r\n  for (const propName in handledResources) {\r\n    if (!allowedProps.includes(propName)) {\r\n      delete handledResources[propName];\r\n    } else if (!correctResources) {\r\n      correctResources = true;\r\n    }\r\n  }\r\n\r\n  // Check if at least one of allowed properties is present\r\n  if (!correctResources) {\r\n    return null;\r\n  }\r\n\r\n  // Handle files section\r\n  if (handledResources.files) {\r\n    handledResources.files = handledResources.files.map((item) => item.trim());\r\n    if (!handledResources.files || handledResources.files.length <= 0) {\r\n      delete handledResources.files;\r\n    }\r\n  }\r\n\r\n  // Return resources\r\n  return handledResources;\r\n}\r\n\r\n/**\r\n * Handles custom code to execute it safely.\r\n *\r\n * @function _handleCustomCode\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nfunction _handleCustomCode(customCode, allowFileResources, isCallback = false) {\r\n  if (customCode && typeof customCode === 'string') {\r\n    customCode = customCode.trim();\r\n\r\n    if (customCode.endsWith('.js')) {\r\n      // Load a file if the file resources are allowed\r\n      return allowFileResources\r\n        ? _handleCustomCode(\r\n            readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n            allowFileResources,\r\n            isCallback\r\n          )\r\n        : null;\r\n    } else if (\r\n      !isCallback &&\r\n      (customCode.startsWith('function()') ||\r\n        customCode.startsWith('function ()') ||\r\n        customCode.startsWith('()=>') ||\r\n        customCode.startsWith('() =>'))\r\n    ) {\r\n      // Treat a function as a self-invoking expression\r\n      return `(${customCode})()`;\r\n    }\r\n\r\n    // Or return as a stringified code\r\n    return customCode.replace(/;$/, '');\r\n  }\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is `true`), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to `null`. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to `null`.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n */\r\nfunction _handleGlobalAndTheme(exportOptions, customLogicOptions) {\r\n  // Get the `allowFileResources` and `allowCodeExecution` flags\r\n  const { allowFileResources, allowCodeExecution } = customLogicOptions;\r\n\r\n  // Check the `globalOptions` and `themeOptions` options\r\n  ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n    try {\r\n      // Check if the option exists\r\n      if (exportOptions[optionsName]) {\r\n        // Check if it is a string and a file name with the `.json` extension\r\n        if (\r\n          allowFileResources &&\r\n          typeof exportOptions[optionsName] === 'string' &&\r\n          exportOptions[optionsName].endsWith('.json')\r\n        ) {\r\n          // Check if the file content can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        } else {\r\n          // Check if the value can be a config, and save it as a string\r\n          exportOptions[optionsName] = isAllowedConfig(\r\n            exportOptions[optionsName],\r\n            true,\r\n            allowCodeExecution\r\n          );\r\n        }\r\n\r\n        // Validate the option\r\n        exportOptions[optionsName] = validateOption(\r\n          optionsName,\r\n          exportOptions[optionsName]\r\n        );\r\n      }\r\n    } catch (error) {\r\n      logWithStack(\r\n        2,\r\n        error,\r\n        `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n      );\r\n\r\n      // In case of an error, set the option with null\r\n      exportOptions[optionsName] = null;\r\n    }\r\n  });\r\n\r\n  // Check if there is the `globalOptions` present\r\n  if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n    log(3, '[chart] No value for the `globalOptions` option found.');\r\n  }\r\n\r\n  // Check if there is the `themeOptions` present\r\n  if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n    log(3, '[chart] No value for the `themeOptions` option found.');\r\n  }\r\n}\r\n\r\n/**\r\n * Validates the size of the data for the export process against a fixed limit\r\n * of 100MB.\r\n *\r\n * @function _checkDataSize\r\n *\r\n * @param {Object} imageOptions - The data object, which includes options from\r\n * the `export` and `customLogic` sections and will be sent to a Puppeteer page.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the size of the data for\r\n * the export process object exceeds the 100MB limit.\r\n */\r\nfunction _checkDataSize(imageOptions) {\r\n  // Set the fixed data limit (100MB) for the dev-tools protocol\r\n  const dataLimit = 100 * 1024 * 1024;\r\n\r\n  // Get the size of the data\r\n  const totalSize = Buffer.byteLength(JSON.stringify(imageOptions), 'utf-8');\r\n\r\n  // Log the size in MB\r\n  log(\r\n    3,\r\n    `[chart] The current total size of the data for the export process is around ${(\r\n      totalSize /\r\n      (1024 * 1024)\r\n    ).toFixed(2)}MB.`\r\n  );\r\n\r\n  // Check the size of data before passing to a page\r\n  if (totalSize >= dataLimit) {\r\n    throw new ExportError(\r\n      `[chart] The data for the export process exceeds 100MB limit.`\r\n    );\r\n  }\r\n}\r\n\r\nexport default {\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n  getAllowCodeExecution,\r\n  setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed to avoid potential\r\n * memory leaks, unintended behavior or a process from being stopped.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n  timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n  log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n  for (const id of timerIds) {\r\n    clearInterval(id);\r\n    clearTimeout(id);\r\n  }\r\n}\r\n\r\nexport default {\r\n  addTimer,\r\n  clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n  // Display the error with stack in a correct format\r\n  logWithStack(1, error);\r\n\r\n  // Delete the stack for the environment other than the development\r\n  if (getOptions().other.nodeEnv !== 'development') {\r\n    delete error.stack;\r\n  }\r\n\r\n  // Call the `returnErrorMiddleware` middleware\r\n  return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n  // Gather all requied information for the response\r\n  const { message, stack } = error;\r\n\r\n  // Use the error's status code or the default 400\r\n  const statusCode = error.statusCode || 400;\r\n\r\n  // Set and return response\r\n  response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n  // Add log error middleware\r\n  app.use(logErrorMiddleware);\r\n\r\n  // Add set status and return error middleware\r\n  app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n  try {\r\n    // Check if the rate limiting is enabled and the app exists\r\n    if (app && rateLimitingOptions.enable) {\r\n      const message =\r\n        'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n      // Options for the rate limiter\r\n      const rateOptions = {\r\n        window: rateLimitingOptions.window || 1,\r\n        maxRequests: rateLimitingOptions.maxRequests || 30,\r\n        delay: rateLimitingOptions.delay || 0,\r\n        trustProxy: rateLimitingOptions.trustProxy || false,\r\n        skipKey: rateLimitingOptions.skipKey || null,\r\n        skipToken: rateLimitingOptions.skipToken || null\r\n      };\r\n\r\n      // Set if behind a proxy\r\n      if (rateOptions.trustProxy) {\r\n        app.enable('trust proxy');\r\n      }\r\n\r\n      // Create a limiter\r\n      const limiter = rateLimit({\r\n        // Time frame for which requests are checked and remembered\r\n        windowMs: rateOptions.window * 60 * 1000,\r\n        // Limit each IP to 100 requests per `windowMs`\r\n        limit: rateOptions.maxRequests,\r\n        // Disable delaying, full speed until the max limit is reached\r\n        delayMs: rateOptions.delay,\r\n        handler: (request, response) => {\r\n          response.format({\r\n            json: () => {\r\n              response.status(429).send({ message });\r\n            },\r\n            default: () => {\r\n              response.status(429).send(message);\r\n            }\r\n          });\r\n        },\r\n        skip: (request) => {\r\n          // Allow bypassing the limiter if a valid key/token has been sent\r\n          if (\r\n            rateOptions.skipKey !== null &&\r\n            rateOptions.skipToken !== null &&\r\n            request.query.key === rateOptions.skipKey &&\r\n            request.query.access_token === rateOptions.skipToken\r\n          ) {\r\n            log(4, '[rate limiting] Skipping rate limiter.');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n\r\n      // Use a limiter as a middleware\r\n      app.use(limiter);\r\n\r\n      log(\r\n        3,\r\n        `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n      );\r\n    }\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[rate limiting] Could not configure and set the rate limiting options.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n  try {\r\n    // Get the content type header\r\n    const contentType = request.headers['content-type'] || '';\r\n\r\n    // Allow only JSON, URL-encoded and form data without files types of data\r\n    if (\r\n      !contentType.includes('application/json') &&\r\n      !contentType.includes('application/x-www-form-urlencoded') &&\r\n      !contentType.includes('multipart/form-data')\r\n    ) {\r\n      throw new ExportError(\r\n        '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n        415\r\n      );\r\n    }\r\n\r\n    // Call the `requestBodyMiddleware` middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n  try {\r\n    // Get the request body\r\n    const body = request.body;\r\n\r\n    // Create a unique ID for a request\r\n    const requestId = uuid();\r\n\r\n    // Throw an error if there is no correct body\r\n    if (!body || isObjectEmpty(body)) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is empty.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get the `allowCodeExecution` option for the server\r\n    const allowCodeExecution = getAllowCodeExecution();\r\n\r\n    // Find a correct chart options\r\n    const instr = isAllowedConfig(\r\n      // Use one of the below\r\n      body.instr || body.options || body.infile || body.data,\r\n      // Stringify options\r\n      true,\r\n      // Allow or disallow functions\r\n      allowCodeExecution\r\n    );\r\n\r\n    // Throw an error if there is no correct chart data\r\n    if (instr === null && !body.svg) {\r\n      log(\r\n        2,\r\n        `[validation] Request [${requestId}] - The request from ${\r\n          request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n        } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n      );\r\n\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Throw an error if test of xlink:href elements from payload's SVG fails\r\n    if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n      throw new ExportError(\r\n        `[validation] Request [${requestId}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n        400\r\n      );\r\n    }\r\n\r\n    // Get and pre-validate the options and store them in the request\r\n    request.validatedOptions = {\r\n      // Set the created ID as a `requestId` property in the options\r\n      requestId,\r\n      export: {\r\n        instr,\r\n        svg: body.svg,\r\n        outfile:\r\n          body.outfile ||\r\n          `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n        type: body.type,\r\n        constr: body.constr,\r\n        b64: body.b64,\r\n        noDownload: body.noDownload,\r\n        height: body.height,\r\n        width: body.width,\r\n        scale: body.scale,\r\n        globalOptions: isAllowedConfig(\r\n          body.globalOptions,\r\n          true,\r\n          allowCodeExecution\r\n        ),\r\n        themeOptions: isAllowedConfig(\r\n          body.themeOptions,\r\n          true,\r\n          allowCodeExecution\r\n        )\r\n      },\r\n      customLogic: {\r\n        allowCodeExecution,\r\n        allowFileResources: false,\r\n        customCode: body.customCode,\r\n        callback: body.callback,\r\n        resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n      }\r\n    };\r\n\r\n    // Call the next middleware\r\n    return next();\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n  // Add content type validation middleware\r\n  app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n  // Add request body request validation middleware\r\n  app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n  png: 'image/png',\r\n  jpeg: 'image/jpeg',\r\n  gif: 'image/gif',\r\n  pdf: 'application/pdf',\r\n  svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n  try {\r\n    // Start counting time for a request\r\n    const requestCounter = measureTime();\r\n\r\n    // In case the connection is closed, force to abort further actions\r\n    let connectionAborted = false;\r\n    request.socket.on('close', (hadErrors) => {\r\n      if (hadErrors) {\r\n        connectionAborted = true;\r\n      }\r\n    });\r\n\r\n    // Get the options previously validated in the validation middleware\r\n    const options = request.validatedOptions;\r\n\r\n    // Get the request id\r\n    const requestId = options.requestId;\r\n\r\n    // Info about an incoming request with correct data\r\n    log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n    // Start the export process\r\n    await startExport(options, (error, data) => {\r\n      // Remove the close event from the socket\r\n      request.socket.removeAllListeners('close');\r\n\r\n      // If the connection was closed, do nothing\r\n      if (connectionAborted) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n        );\r\n        return;\r\n      }\r\n\r\n      // If error, log it and send it to the error middleware\r\n      if (error) {\r\n        throw error;\r\n      }\r\n\r\n      // If data is missing, log the message and send it to the error middleware\r\n      if (!data || !data.result) {\r\n        log(\r\n          2,\r\n          `[export] Request [${requestId}] - Request from ${\r\n            request.headers['x-forwarded-for'] ||\r\n            request.connection.remoteAddress\r\n          } was incorrect. Received result is ${data.result}.`\r\n        );\r\n\r\n        throw new ExportError(\r\n          `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n          400\r\n        );\r\n      }\r\n\r\n      // Return the result in an appropriate format\r\n      if (data.result) {\r\n        log(\r\n          3,\r\n          `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n        );\r\n\r\n        // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n        const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n        // If only Base64 is required, return it\r\n        if (b64) {\r\n          return response.send(getBase64(data.result, type));\r\n        }\r\n\r\n        // Set correct content type\r\n        response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n        // Decide whether to download or not chart file\r\n        if (!noDownload) {\r\n          response.attachment(outfile);\r\n        }\r\n\r\n        // If SVG, return plain content, otherwise a b64 string from a buffer\r\n        return type === 'svg'\r\n          ? response.send(data.result)\r\n          : response.send(Buffer.from(data.result, 'base64'));\r\n      }\r\n    });\r\n  } catch (error) {\r\n    return next(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n  /**\r\n   * Adds the POST '/' - A route for handling POST requests at the root\r\n   * endpoint.\r\n   */\r\n  app.post('/', requestExport);\r\n\r\n  /**\r\n   * Adds the POST '/:filename' - A route for handling POST requests with\r\n   * a specified filename parameter.\r\n   */\r\n  app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n  readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n  return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n  return setInterval(() => {\r\n    const stats = getPoolStats();\r\n    const successRatio =\r\n      stats.exportsAttempted === 0\r\n        ? 1\r\n        : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n    successRates.push(successRatio);\r\n    if (successRates.length > windowSize) {\r\n      successRates.shift();\r\n    }\r\n  }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n  // Start processing success rate ratio interval and save its id to the array\r\n  // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n  addTimer(_startSuccessRate());\r\n\r\n  /**\r\n   * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n   */\r\n  app.get('/health', (request, response, next) => {\r\n    try {\r\n      log(4, '[health] Returning server health.');\r\n\r\n      const stats = getPoolStats();\r\n      const period = successRates.length;\r\n      const movingAverage = _calculateMovingAverage();\r\n\r\n      // Send the server's statistics\r\n      response.send({\r\n        // Status and times\r\n        status: 'OK',\r\n        bootTime: serverStartTime,\r\n        uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n        // Versions\r\n        serverVersion: packageFile.version,\r\n        highchartsVersion: getHcVersion(),\r\n\r\n        // Exports\r\n        averageExportTime: stats.timeSpentAverage,\r\n        attemptedExports: stats.exportsAttempted,\r\n        performedExports: stats.exportsPerformed,\r\n        failedExports: stats.exportsDropped,\r\n        sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n        // Pool\r\n        pool: getPoolInfoJSON(),\r\n\r\n        // Moving average\r\n        period,\r\n        movingAverage,\r\n        message:\r\n          isNaN(movingAverage) || !successRates.length\r\n            ? 'Too early to report. No exports made yet. Please check back soon.'\r\n            : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n        // SVG and JSON exports\r\n        svgExports: stats.exportsFromSvg,\r\n        jsonExports: stats.exportsFromOptions,\r\n        svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n        jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n      });\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n  // Add the UI endpoint only if required\r\n  if (getOptions().ui.enable) {\r\n    /**\r\n     * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n     */\r\n    app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n      try {\r\n        log(4, '[ui] Returning UI for the export.');\r\n\r\n        response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n          acceptRanges: false\r\n        });\r\n      } catch (error) {\r\n        return next(error);\r\n      }\r\n    });\r\n  }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHcVersion, updateHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n  /**\r\n   * Adds the POST '/version_change/:newVersion' - A route for changing\r\n   * the Highcharts version on the server.\r\n   */\r\n  app.post('/version_change/:newVersion', async (request, response, next) => {\r\n    try {\r\n      log(4, '[version] Changing Highcharts version.');\r\n\r\n      // Get the token directly from envs\r\n      const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n      // Check the existence of the token\r\n      if (!adminToken || !adminToken.length) {\r\n        throw new ExportError(\r\n          '[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the token from the hc-auth header\r\n      const token = request.get('hc-auth');\r\n\r\n      // Check if the hc-auth header contain a correct token\r\n      if (!token || token !== adminToken) {\r\n        throw new ExportError(\r\n          '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n          401\r\n        );\r\n      }\r\n\r\n      // Get the new version from the params\r\n      const newVersion = request.params.newVersion;\r\n\r\n      // Update version\r\n      if (newVersion) {\r\n        try {\r\n          await updateHcVersion(newVersion);\r\n        } catch (error) {\r\n          throw new ExportError(\r\n            `[version] Version change: ${error.message}`,\r\n            400\r\n          ).setError(error);\r\n        }\r\n\r\n        // Success\r\n        response.status(200).send({\r\n          statusCode: 200,\r\n          highchartsVersion: getHcVersion(),\r\n          message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n        });\r\n      } else {\r\n        // No version specified\r\n        throw new ExportError('[version] No new version supplied.', 400);\r\n      }\r\n    } catch (error) {\r\n      return next(error);\r\n    }\r\n  });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middlewares setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} [serverOptions={}] - The configuration object containing\r\n * `server` options. This object may include a partial or complete set\r\n * of the `server` options. If the options are partial, missing values will\r\n * default to the current global configuration. The default value is an empty\r\n * object.\r\n *\r\n * @returns {Promise<void>} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions = {}) {\r\n  try {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      server: serverOptions\r\n    });\r\n\r\n    // Use validated options\r\n    serverOptions = options.server;\r\n\r\n    // Stop if not enabled\r\n    if (!serverOptions.enable || !app) {\r\n      throw new ExportError(\r\n        '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n        500\r\n      );\r\n    }\r\n\r\n    // Too big limits lead to timeouts in the export process when\r\n    // the rasterization timeout is set too low\r\n    const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n    // Memory storage for multer package\r\n    const storage = multer.memoryStorage();\r\n\r\n    // Enable parsing of form data (files) with multer package\r\n    const upload = multer({\r\n      storage,\r\n      limits: {\r\n        fieldSize: uploadLimitBytes\r\n      }\r\n    });\r\n\r\n    // Disable the X-Powered-By header\r\n    app.disable('x-powered-by');\r\n\r\n    // Enable CORS support\r\n    app.use(\r\n      cors({\r\n        methods: ['POST', 'GET', 'OPTIONS']\r\n      })\r\n    );\r\n\r\n    // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n    // is a deprecated options, let's try to set it to false)\r\n    app.use((request, response, next) => {\r\n      response.set('Accept-Ranges', 'none');\r\n      next();\r\n    });\r\n\r\n    // Enable body parser for JSON data\r\n    app.use(\r\n      express.json({\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Enable body parser for URL-encoded form data\r\n    app.use(\r\n      express.urlencoded({\r\n        extended: true,\r\n        limit: uploadLimitBytes\r\n      })\r\n    );\r\n\r\n    // Use only non-file multipart form fields\r\n    app.use(upload.none());\r\n\r\n    // Set up static folder's route\r\n    app.use(express.static(join(__dirname, 'public')));\r\n\r\n    // Listen HTTP server\r\n    if (!serverOptions.ssl.force) {\r\n      // Main server instance (HTTP)\r\n      const httpServer = http.createServer(app);\r\n\r\n      // Attach error handlers and listen to the server\r\n      _attachServerErrorHandlers(httpServer);\r\n\r\n      // Listen\r\n      httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n        // Save the reference to HTTP server\r\n        activeServers.set(serverOptions.port, httpServer);\r\n\r\n        log(\r\n          3,\r\n          `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n        );\r\n      });\r\n    }\r\n\r\n    // Listen HTTPS server\r\n    if (serverOptions.ssl.enable) {\r\n      // Set up an SSL server also\r\n      let key, cert;\r\n\r\n      try {\r\n        // Get the SSL key\r\n        key = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n          'utf8'\r\n        );\r\n\r\n        // Get the SSL certificate\r\n        cert = readFileSync(\r\n          join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n          'utf8'\r\n        );\r\n      } catch (error) {\r\n        log(\r\n          2,\r\n          `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n        );\r\n      }\r\n\r\n      if (key && cert) {\r\n        // Main server instance (HTTPS)\r\n        const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n        // Attach error handlers and listen to the server\r\n        _attachServerErrorHandlers(httpsServer);\r\n\r\n        // Listen\r\n        httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n          // Save the reference to HTTPS server\r\n          activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n          log(\r\n            3,\r\n            `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n          );\r\n        });\r\n      }\r\n    }\r\n\r\n    // Set up the rate limiter\r\n    rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n    // Set up the validation handler\r\n    validationMiddleware(app);\r\n\r\n    // Set up routes\r\n    exportRoutes(app);\r\n    healthRoutes(app);\r\n    uiRoutes(app);\r\n    versionChangeRoutes(app);\r\n\r\n    // Set up the centralized error handler\r\n    errorMiddleware(app);\r\n  } catch (error) {\r\n    throw new ExportError(\r\n      '[server] Could not configure and start the server.',\r\n      500\r\n    ).setError(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n  // Check if there are servers working\r\n  if (activeServers.size > 0) {\r\n    log(4, `[server] Closing all servers.`);\r\n\r\n    // Close each one of servers\r\n    for (const [port, server] of activeServers) {\r\n      server.close(() => {\r\n        activeServers.delete(port);\r\n        log(4, `[server] Closed server on port: ${port}.`);\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array<Object>} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n  return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n  return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n  return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n  // Update the instance options object\r\n  const options = updateOptions({\r\n    server: {\r\n      rateLimiting: rateLimitingOptions\r\n    }\r\n  });\r\n\r\n  // Set the rate limiting options\r\n  rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n  app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n  app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n  app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n  server.on('clientError', (error, socket) => {\r\n    logWithStack(\r\n      1,\r\n      error,\r\n      `[server] Client error: ${error.message}, destroying socket.`\r\n    );\r\n    socket.destroy();\r\n  });\r\n\r\n  server.on('error', (error) => {\r\n    logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n  });\r\n\r\n  server.on('connection', (socket) => {\r\n    socket.on('error', (error) => {\r\n      logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n    });\r\n  });\r\n}\r\n\r\nexport default {\r\n  startServer,\r\n  closeServers,\r\n  getServers,\r\n  getExpress,\r\n  getApp,\r\n  enableRateLimiting,\r\n  use,\r\n  get,\r\n  post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n  // Await freeing all resources\r\n  await Promise.allSettled([\r\n    // Clear all ongoing intervals\r\n    clearAllTimers(),\r\n\r\n    // Get available server instances (HTTP/HTTPS) and close them\r\n    closeServers(),\r\n\r\n    // Close an active pool along with its workers and the browser instance\r\n    killPool()\r\n  ]);\r\n\r\n  // Exit process with a correct code\r\n  process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n  shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This core module initializes and manages the Highcharts Export\r\n * Server. The main `initExport` function handles logging, script caching,\r\n * resource pooling, browser startup, and ensures graceful process cleanup\r\n * on exit. Additionally, it provides API functions for using it as a Node.js\r\n * module, offering functionalities for processing options, configuring\r\n * and performing exports, and setting up server.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkCache } from './cache.js';\r\nimport {\r\n  batchExport,\r\n  singleExport,\r\n  startExport,\r\n  setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n  validateOption,\r\n  validateOptions\r\n} from './config.js';\r\nimport {\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  initLogging,\r\n  enableConsoleLogging,\r\n  enableFileLogging,\r\n  setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n  // Init, validate and update the options object\r\n  const options = updateOptions(initOptions);\r\n\r\n  // Set the `allowCodeExecution` per export module scope\r\n  setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n  // Init the logging\r\n  initLogging(options.logging);\r\n\r\n  // Attach process' exit listeners\r\n  if (options.other.listenToProcessExits) {\r\n    _attachProcessExitListeners();\r\n  }\r\n\r\n  // Check the current status of cache\r\n  await checkCache(options.highcharts, options.server.proxy);\r\n\r\n  // Init the pool\r\n  await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM',\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n  log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n  // Handler for the 'exit'\r\n  process.on('exit', (code) => {\r\n    log(4, `[process] Process exited with code: ${code}.`);\r\n  });\r\n\r\n  // Handler for the 'SIGINT'\r\n  process.on('SIGINT', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGTERM'\r\n  process.on('SIGTERM', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'SIGHUP'\r\n  process.on('SIGHUP', async (name, code) => {\r\n    log(4, `[process] The ${name} event with code: ${code}.`);\r\n    await shutdownCleanUp();\r\n  });\r\n\r\n  // Handler for the 'uncaughtException'\r\n  process.on('uncaughtException', async (error, name) => {\r\n    logWithStack(1, error, `[process] The ${name} error.`);\r\n    await shutdownCleanUp(1);\r\n  });\r\n}\r\n\r\nexport default {\r\n  // Server\r\n  ...server,\r\n\r\n  // Options\r\n  getOptions,\r\n  updateOptions,\r\n  mapToNewOptions,\r\n\r\n  // Validation\r\n  validateOption,\r\n  validateOptions,\r\n\r\n  // Exporting\r\n  initExport,\r\n  singleExport,\r\n  batchExport,\r\n  startExport,\r\n\r\n  // Release\r\n  killPool,\r\n  shutdownCleanUp,\r\n\r\n  // Logs\r\n  log,\r\n  logWithStack,\r\n  logZodIssues,\r\n  setLogLevel: function (level) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        level\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    setLogLevel(options.logging.level);\r\n  },\r\n  enableConsoleLogging: function (toConsole) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        toConsole\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableConsoleLogging(options.logging.toConsole);\r\n  },\r\n  enableFileLogging: function (dest, file, toFile) {\r\n    // Update the instance options object\r\n    const options = updateOptions({\r\n      logging: {\r\n        dest,\r\n        file,\r\n        toFile\r\n      }\r\n    });\r\n\r\n    // Call the function\r\n    enableFileLogging(\r\n      options.logging.dest,\r\n      options.logging.file,\r\n      options.logging.toFile\r\n    );\r\n  }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","document","require","pathToFileURL","__filename","href","_documentCurrentScript","tagName","toUpperCase","src","baseURI","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","getAbsolutePath","path","isAbsolute","normalize","resolve","getBase64","input","type","Buffer","from","toString","getNewDate","Date","split","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","shift","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","outfile","hint","choices","constr","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","allowFileResources","customCode","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","dotenv","config","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","includes","nullable","string","refine","params","errorMessage","values","stringArray","filterCallback","arraySchema","array","stringSchema","startsWith","slice","endsWith","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","forEach","index","substring","ExportError","Error","constructor","statusCode","super","setError","name","_initOptions","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","validateOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","propChain","entry","async","get","url","requestOptions","Promise","reject","_getProtocolModule","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","readFileSync","modules","moduleMap","m","numberOfModules","moduleName","_extractHcVersion","_saveConfigToManifest","getHcVersion","updateHcVersion","newVersion","writeFileSync","_configureRequest","all","cs","_fetchScript","ms","is","script","shouldThrowError","_extractModuleName","agent","HttpsProxyAgent","cacheSources","replace","scriptPath","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","images","querySelectorAll","race","image","complete","naturalHeight","addEventListener","once","setTimeout","defaultOptions","pageTemplate","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","openBrowser","launch","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","_getChartSize","x","y","_getClipRegion","viewportHeight","abs","ceil","chartHeight","viewportWidth","chartWidth","result","setViewport","deviceScaleFactor","parseFloat","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","svgElement","querySelector","baseVal","style","zoom","margin","outerHTML","clip","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","i","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","_getPoolInfo","acquireCounter","exportCounter","exportResult","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_fixConstr","_fixType","_fixOutfile","_handleCustomLogic","_handleGlobalAndTheme","_handleSize","_checkDataSize","fixedConstr","toLowerCase","mimeTypes","formats","outType","pop","find","t","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","_handleCustomCode","handledResources","allowedProps","correctResources","propName","isCallback","optionsName","totalSize","byteLength","toFixed","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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SACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,qBACbC,cAAe,CACbnF,KAAM,SAGVuF,OAAQ,CACN7D,MAAO,8BACPqD,MAAO,CAAC,UACRC,QAAS,qBACTE,YAAa,iCACbC,cAAe,CACbnF,KAAM,SAGVwF,WAAY,CACV9D,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGVyF,UAAW,CACT/D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbnF,KAAM,SAGV0F,YAAa,CACXhE,MAAO,CAAC,aAAc,kBAAmB,iBACzCqD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBC,cAAe,CACblE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBE,iBAAkB,CAChBnE,MAAO,CAAC,kBACRqD,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBG,cAAe,CACbpE,MAAO,CACL,wEACA,kGAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbnF,KAAM,OACNoF,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACNtE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACb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"} diff --git a/dist/index.esm.js b/dist/index.esm.js index 5faa6c3d..77682997 100644 --- a/dist/index.esm.js +++ b/dist/index.esm.js @@ -1,2 +1,2 @@ -import"colors";import{existsSync,mkdirSync,appendFile,readFileSync,writeFileSync}from"fs";import{normalize,resolve,isAbsolute,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function getAbsolutePath(e){return isAbsolute(e)?normalize(e):resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"log",logging.file=t||"highcharts-export-server.log")}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}};dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=z.string().trim().array(),i=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig),nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1,o=!0){return _mergeOptions(getOptions(t),validateOptions(e,o))}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty object.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}async function get$1(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkCache(e,t){try{let o;const r=getCachePath(),i=join(r,"manifest.json"),n=join(r,"sources.js");if(!existsSync(r)&&mkdirSync(r,{recursive:!0}),!existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=_extractHcVersion(cache.sources))}await _saveConfigToManifest(e.version,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHcVersion(){return cache.hcVersion}async function updateHcVersion(e){const t=updateOptions({highcharts:{version:e}});await checkCache(t.highcharts,t.server.proxy)}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _saveConfigToManifest(e,t={}){cache.activeManifest={version:e,modules:t},log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(cache.activeManifest),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _updateCache(e,t,o){try{const r="latest"===e.version?null:`${e.version}`;log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`);const i=e.cdnUrl||cache.cdnUrl,n=_configureRequest(t),s={};return cache.sources=(await Promise.all([...e.coreScripts.map((e=>_fetchScript(r?`${i}/${r}/${e}`:`${i}/${e}`,n,s,!0))),...e.moduleScripts.map((e=>_fetchScript("map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`,n,s))),...e.indicatorScripts.map((e=>_fetchScript(r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`,n,s))),...e.customScripts.map((e=>_fetchScript(`${e}`,n)))])).join(";\n"),cache.hcVersion=_extractHcVersion(cache.sources),writeFileSync(o,cache.sources),s}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}async function _fetchScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await get$1(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[_extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}function _configureRequest(e){const t=e.host,o=e.port;if(t&&o)try{return{agent:new HttpsProxyAgent({host:t,port:o}),timeout:e.timeout}}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}return{}}function _extractHcVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function _extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=i(!1,l,a,s),p=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a);const u=new Function(`return ${e.globalOptions}`)();u&&r(u),Highcharts[e.constr]("container",c,p);const d=Array.from(document.querySelectorAll(".highcharts-container image"));await Promise.race([Promise.all(d.map((e=>e.complete&&0!==e.naturalHeight?Promise.resolve():new Promise((t=>e.addEventListener("load",t,{once:!0})))))),new Promise((e=>setTimeout(e,2e3)))]);const g=o();for(const e in g)"function"!=typeof g[e]&&delete g[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const pageTemplate=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to launch and get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){const i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:getAbsolutePath(e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(pageTemplate,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=await _getChartSize(e,i,t.scale),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _getChartSize(e,t,o){return t?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(o)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&_getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),i=await puppeteerExport(t.page,e.export,e.customLogic);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(i):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${r()}ms.`).setError(i);return e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t),poolStats.timeSpent+=r(),poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${r()}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function _getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.options=null,t.export.instr=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.options=null,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.constr=_fixConstr(t.constr),t.type=_fixType(t.type,t.outfile),t.outfile=_fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o),_handleGlobalAndTheme(t,o),_handleSize(t),_checkDataSize({export:t,customLogic:o}),postWork(e)}function _fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function _fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e||"png"}`}function _fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function _handleSize(e){const{chart:t,exporting:o}=isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,l=e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,c=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2);e.height=a,e.width=l,e.scale=c;for(let t of["height","width","scale"])"string"==typeof e[t]&&(e[t]=+e[t].replace(/px|%/gi,""))}function _handleCustomLogic(e){if(e.allowCodeExecution){try{e.resources=_handleResources(e.resources,e.allowFileResources,!0)}catch(t){log(2,"[chart] The `resources` cannot be loaded."),e.resources=null}try{e.customCode=_handleCustomCode(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=_handleCustomCode(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){let r=e;r||(e="resources.json");const i=["js","css","files"];let n=!1;t&&"string"==typeof e&&e.endsWith(".json")?r=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o):(r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files);for(const e in r)i.includes(e)?n||(n=!0):delete r[e];return n?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r=validateOption("resources",r),r):null}function _handleCustomCode(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?_handleCustomCode(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}function _handleGlobalAndTheme(e,t){const{allowFileResources:o,allowCodeExecution:r}=t;["globalOptions","themeOptions"].forEach((t=>{try{e[t]&&(o&&"string"==typeof e[t]&&e[t].endsWith(".json")?e[t]=isAllowedConfig(readFileSync(getAbsolutePath(e[t]),"utf8"),!0,r):e[t]=isAllowedConfig(e[t],!0,r),e[t]=validateOption(t,e[t]))}catch(o){logWithStack(2,o,`[chart] The \`${t}\` cannot be loaded.`),e[t]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}function _checkDataSize(e){const t=Buffer.byteLength(JSON.stringify(e),"utf-8");if(log(3,`[chart] The current total size of the data for the export process is around ${(t/1048576).toFixed(2)}MB.`),t>=104857600)throw new ExportError("[chart] The data for the export process exceeds 100MB limit.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`[validation] Request [${r}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`[validation] Request [${r}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions={requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHcVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){getOptions().ui.enable&&e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const i=e.params.newVersion;if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHcVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHcVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e){const t=updateOptions(e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code: ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};export{index as default,initExport}; +import"colors";import{existsSync,mkdirSync,appendFile,readFileSync,writeFileSync}from"fs";import{normalize,resolve,isAbsolute,join}from"path";import{HttpsProxyAgent}from"https-proxy-agent";import{fileURLToPath}from"url";import dotenv from"dotenv";import{z}from"zod";import http from"http";import https from"https";import{Pool}from"tarn";import{v4}from"uuid";import puppeteer from"puppeteer";import DOMPurify from"dompurify";import{JSDOM}from"jsdom";import cors from"cors";import express from"express";import multer from"multer";import rateLimit from"express-rate-limit";const __dirname=fileURLToPath(new URL("../.",import.meta.url));function deepCopy(e){if(null===e||"object"!=typeof e)return e;const t=Array.isArray(e)?[]:{};for(const o in e)Object.prototype.hasOwnProperty.call(e,o)&&(t[o]=deepCopy(e[o]));return t}function getAbsolutePath(e){return isAbsolute(e)?normalize(e):resolve(e)}function getBase64(e,t){return"pdf"===t||"svg"==t?Buffer.from(e,"utf8").toString("base64"):e}function getNewDate(){return(new Date).toString().split("(")[0].trim()}function getNewDateTime(){return(new Date).getTime()}function isObject(e){return"[object Object]"===Object.prototype.toString.call(e)}function isObjectEmpty(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&0===Object.keys(e).length}function isPrivateRangeUrlFound(e){return[/xlink:href="(?:http:\/\/|https:\/\/)?localhost\b/,/xlink:href="(?:http:\/\/|https:\/\/)?10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}\b/,/xlink:href="(?:http:\/\/|https:\/\/)?192\.168\.\d{1,3}\.\d{1,3}\b/].some((t=>t.test(e)))}function measureTime(){const e=process.hrtime.bigint();return()=>Number(process.hrtime.bigint()-e)/1e6}function roundNumber(e,t=1){const o=Math.pow(10,t||0);return Math.round(+e*o)/o}const colors=["red","yellow","blue","gray","green"],logging={toConsole:!0,toFile:!1,pathCreated:!1,pathToLog:"",levelsDesc:[{title:"error",color:colors[0]},{title:"warning",color:colors[1]},{title:"notice",color:colors[2]},{title:"verbose",color:colors[3]},{title:"benchmark",color:colors[4]}]};function log(...e){const[t,...o]=e,{levelsDesc:r,level:i}=logging;if(5!==t&&(0===t||t>i||i>r.length))return;const n=`${getNewDate()} [${r[t-1].title}] -`;logging.toFile&&_logToFile(o,n),logging.toConsole&&console.log.apply(void 0,[n.toString()[logging.levelsDesc[t-1].color]].concat(o))}function logWithStack(e,t,o){const r=o||t&&t.message||"",{level:i,levelsDesc:n}=logging;if(0===e||e>i||i>n.length)return;const s=`${getNewDate()} [${n[e-1].title}] -`,a=t&&t.stack,l=[r];a&&l.push("\n",a),logging.toFile&&_logToFile(l,s),logging.toConsole&&console.log.apply(void 0,[s.toString()[logging.levelsDesc[e-1].color]].concat([l.shift()[colors[e-1]],...l]))}function logZodIssues(e,t,o){logWithStack(e,null,[`${o||"[validation] Validation error"} - the following Zod issues occured:`,...(t||[]).map((e=>`- ${e.message}`))].join("\n"))}function initLogging(e){const{level:t,dest:o,file:r,toConsole:i,toFile:n}=e;logging.pathCreated=!1,logging.pathToLog="",setLogLevel(t),enableConsoleLogging(i),enableFileLogging(o,r,n)}function setLogLevel(e){Number.isInteger(e)&&e>=0&&e<=logging.levelsDesc.length&&(logging.level=e)}function enableConsoleLogging(e){logging.toConsole=!!e}function enableFileLogging(e,t,o){logging.toFile=!!o,logging.toFile&&(logging.dest=e||"log",logging.file=t||"highcharts-export-server.log")}function _logToFile(e,t){logging.pathCreated||(!existsSync(getAbsolutePath(logging.dest))&&mkdirSync(getAbsolutePath(logging.dest)),logging.pathToLog=getAbsolutePath(join(logging.dest,logging.file)),logging.pathCreated=!0),appendFile(logging.pathToLog,[t].concat(e).join(" ")+"\n",(e=>{e&&logging.toFile&&logging.pathCreated&&(logging.toFile=!1,logging.pathCreated=!1,logWithStack(2,e,"[logger] Unable to write to log file."))}))}const defaultConfig={puppeteer:{args:{value:["--allow-running-insecure-content","--ash-no-nudges","--autoplay-policy=user-gesture-required","--block-new-web-contents","--disable-accelerated-2d-canvas","--disable-background-networking","--disable-background-timer-throttling","--disable-backgrounding-occluded-windows","--disable-breakpad","--disable-checker-imaging","--disable-client-side-phishing-detection","--disable-component-extensions-with-background-pages","--disable-component-update","--disable-default-apps","--disable-dev-shm-usage","--disable-domain-reliability","--disable-extensions","--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP","--disable-hang-monitor","--disable-ipc-flooding-protection","--disable-logging","--disable-notifications","--disable-offer-store-unmasked-wallet-cards","--disable-popup-blocking","--disable-print-preview","--disable-prompt-on-repost","--disable-renderer-backgrounding","--disable-search-engine-choice-screen","--disable-session-crashed-bubble","--disable-setuid-sandbox","--disable-site-isolation-trials","--disable-speech-api","--disable-sync","--enable-unsafe-webgpu","--hide-crash-restore-bubble","--hide-scrollbars","--metrics-recording-only","--mute-audio","--no-default-browser-check","--no-first-run","--no-pings","--no-sandbox","--no-startup-window","--no-zygote","--password-store=basic","--process-per-tab","--use-mock-keychain"],types:["string[]"],envLink:"PUPPETEER_ARGS",cliName:"puppeteerArgs",description:"Array of Puppeteer arguments",promptOptions:{type:"list",separator:";"}}},highcharts:{version:{value:"latest",types:["string"],envLink:"HIGHCHARTS_VERSION",description:"Highcharts version",promptOptions:{type:"text"}},cdnUrl:{value:"https://code.highcharts.com",types:["string"],envLink:"HIGHCHARTS_CDN_URL",description:"CDN URL for Highcharts scripts",promptOptions:{type:"text"}},forceFetch:{value:!1,types:["boolean"],envLink:"HIGHCHARTS_FORCE_FETCH",description:"Flag to refetch scripts after each server rerun",promptOptions:{type:"toggle"}},cachePath:{value:".cache",types:["string"],envLink:"HIGHCHARTS_CACHE_PATH",description:"Directory path for cached Highcharts scripts",promptOptions:{type:"text"}},coreScripts:{value:["highcharts","highcharts-more","highcharts-3d"],types:["string[]"],envLink:"HIGHCHARTS_CORE_SCRIPTS",description:"Highcharts core scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},moduleScripts:{value:["stock","map","gantt","exporting","parallel-coordinates","accessibility","boost-canvas","boost","data","data-tools","draggable-points","static-scale","broken-axis","heatmap","tilemap","tiledwebmap","timeline","treemap","treegraph","item-series","drilldown","histogram-bellcurve","bullet","funnel","funnel3d","geoheatmap","pyramid3d","networkgraph","overlapping-datalabels","pareto","pattern-fill","pictorial","price-indicator","sankey","arc-diagram","dependency-wheel","series-label","series-on-point","solid-gauge","sonification","streamgraph","sunburst","variable-pie","variwide","vector","venn","windbarb","wordcloud","xrange","no-data-to-display","drag-panes","debugger","dumbbell","lollipop","cylinder","organization","dotplot","marker-clusters","hollowcandlestick","heikinashi","flowmap","export-data","navigator","textpath"],types:["string[]"],envLink:"HIGHCHARTS_MODULE_SCRIPTS",description:"Highcharts module scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},indicatorScripts:{value:["indicators-all"],types:["string[]"],envLink:"HIGHCHARTS_INDICATOR_SCRIPTS",description:"Highcharts indicator scripts to fetch",promptOptions:{type:"multiselect",instructions:"Space: Select specific, A: Select all, Enter: Confirm"}},customScripts:{value:["https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js","https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js"],types:["string[]"],envLink:"HIGHCHARTS_CUSTOM_SCRIPTS",description:"Additional custom scripts or dependencies to fetch",promptOptions:{type:"list",separator:";"}}},export:{infile:{value:null,types:["string","null"],envLink:"EXPORT_INFILE",description:"Input filename with type, formatted correctly as JSON or SVG",promptOptions:{type:"text"}},instr:{value:null,types:["Object","string","null"],envLink:"EXPORT_INSTR",description:"Overrides the `infile` with JSON, stringified JSON, or SVG input",promptOptions:{type:"text"}},options:{value:null,types:["Object","string","null"],envLink:"EXPORT_OPTIONS",description:"Alias for the `instr` option",promptOptions:{type:"text"}},svg:{value:null,types:["string","null"],envLink:"EXPORT_SVG",description:"SVG string representation of the chart to render",promptOptions:{type:"text"}},batch:{value:null,types:["string","null"],envLink:"EXPORT_BATCH",description:'Batch job string with input/output pairs: "in=out;in=out;..."',promptOptions:{type:"text"}},outfile:{value:null,types:["string","null"],envLink:"EXPORT_OUTFILE",description:"Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option",promptOptions:{type:"text"}},type:{value:"png",types:["string"],envLink:"EXPORT_TYPE",description:"File export format. Can be jpeg, png, pdf, or svg",promptOptions:{type:"select",hint:"Default: png",choices:["png","jpeg","pdf","svg"]}},constr:{value:"chart",types:["string"],envLink:"EXPORT_CONSTR",description:"Chart constructor. Can be chart, stockChart, mapChart, or ganttChart",promptOptions:{type:"select",hint:"Default: chart",choices:["chart","stockChart","mapChart","ganttChart"]}},b64:{value:!1,types:["boolean"],envLink:"EXPORT_B64",description:"Whether or not to the chart should be received in Base64 format instead of binary",promptOptions:{type:"toggle"}},noDownload:{value:!1,types:["boolean"],envLink:"EXPORT_NO_DOWNLOAD",description:"Whether or not to include or exclude attachment headers in the response",promptOptions:{type:"toggle"}},height:{value:null,types:["number","null"],envLink:"EXPORT_HEIGHT",description:"Height of the exported chart, overrides chart settings",promptOptions:{type:"number"}},width:{value:null,types:["number","null"],envLink:"EXPORT_WIDTH",description:"Width of the exported chart, overrides chart settings",promptOptions:{type:"number"}},scale:{value:null,types:["number","null"],envLink:"EXPORT_SCALE",description:"Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0",promptOptions:{type:"number"}},defaultHeight:{value:400,types:["number"],envLink:"EXPORT_DEFAULT_HEIGHT",description:"Default height of the exported chart if not set",promptOptions:{type:"number"}},defaultWidth:{value:600,types:["number"],envLink:"EXPORT_DEFAULT_WIDTH",description:"Default width of the exported chart if not set",promptOptions:{type:"number"}},defaultScale:{value:1,types:["number"],envLink:"EXPORT_DEFAULT_SCALE",description:"Default scale of the exported chart if not set. Ranges from 0.1 to 5.0",promptOptions:{type:"number",min:.1,max:5}},globalOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_GLOBAL_OPTIONS",description:"JSON, stringified JSON or filename with global options for Highcharts.setOptions",promptOptions:{type:"text"}},themeOptions:{value:null,types:["Object","string","null"],envLink:"EXPORT_THEME_OPTIONS",description:"JSON, stringified JSON or filename with theme options for Highcharts.setOptions",promptOptions:{type:"text"}},rasterizationTimeout:{value:1500,types:["number"],envLink:"EXPORT_RASTERIZATION_TIMEOUT",description:"Milliseconds to wait for webpage rendering",promptOptions:{type:"number"}}},customLogic:{allowCodeExecution:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_CODE_EXECUTION",description:"Allows or disallows execution of arbitrary code during exporting",promptOptions:{type:"toggle"}},allowFileResources:{value:!1,types:["boolean"],envLink:"CUSTOM_LOGIC_ALLOW_FILE_RESOURCES",description:"Allows or disallows injection of filesystem resources (disabled in server mode)",promptOptions:{type:"toggle"}},customCode:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CUSTOM_CODE",description:"Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename",promptOptions:{type:"text"}},callback:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CALLBACK",description:"JavaScript code to run during construction. Can be a function or a .js filename",promptOptions:{type:"text"}},resources:{value:null,types:["Object","string","null"],envLink:"CUSTOM_LOGIC_RESOURCES",description:"Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections",promptOptions:{type:"text"}},loadConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_LOAD_CONFIG",legacyName:"fromFile",description:"File with a pre-defined configuration to use",promptOptions:{type:"text"}},createConfig:{value:null,types:["string","null"],envLink:"CUSTOM_LOGIC_CREATE_CONFIG",description:"Prompt-based option setting, saved to a provided config file",promptOptions:{type:"text"}}},server:{enable:{value:!1,types:["boolean"],envLink:"SERVER_ENABLE",cliName:"enableServer",description:"Starts the server when true",promptOptions:{type:"toggle"}},host:{value:"0.0.0.0",types:["string"],envLink:"SERVER_HOST",description:"Hostname of the server",promptOptions:{type:"text"}},port:{value:7801,types:["number"],envLink:"SERVER_PORT",description:"Port number for the server",promptOptions:{type:"number"}},uploadLimit:{value:3,types:["number"],envLink:"SERVER_UPLOAD_LIMIT",description:"Maximum request body size in MB",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"SERVER_BENCHMARKING",cliName:"serverBenchmarking",description:"Displays or not action durations in milliseconds during server requests",promptOptions:{type:"toggle"}},proxy:{host:{value:null,types:["string","null"],envLink:"SERVER_PROXY_HOST",cliName:"proxyHost",description:"Host of the proxy server, if applicable",promptOptions:{type:"text"}},port:{value:null,types:["number","null"],envLink:"SERVER_PROXY_PORT",cliName:"proxyPort",description:"Port of the proxy server, if applicable",promptOptions:{type:"number"}},timeout:{value:5e3,types:["number"],envLink:"SERVER_PROXY_TIMEOUT",cliName:"proxyTimeout",description:"Timeout in milliseconds for the proxy server, if applicable",promptOptions:{type:"number"}}},rateLimiting:{enable:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_ENABLE",cliName:"enableRateLimiting",description:"Enables or disables rate limiting on the server",promptOptions:{type:"toggle"}},maxRequests:{value:10,types:["number"],envLink:"SERVER_RATE_LIMITING_MAX_REQUESTS",legacyName:"rateLimit",description:"Maximum number of requests allowed per minute",promptOptions:{type:"number"}},window:{value:1,types:["number"],envLink:"SERVER_RATE_LIMITING_WINDOW",description:"Time window in minutes for rate limiting",promptOptions:{type:"number"}},delay:{value:0,types:["number"],envLink:"SERVER_RATE_LIMITING_DELAY",description:"Delay duration between successive requests before reaching the limit",promptOptions:{type:"number"}},trustProxy:{value:!1,types:["boolean"],envLink:"SERVER_RATE_LIMITING_TRUST_PROXY",description:"Set to true if the server is behind a load balancer",promptOptions:{type:"toggle"}},skipKey:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_KEY",description:"Key to bypass the rate limiter, used with `skipToken`",promptOptions:{type:"text"}},skipToken:{value:null,types:["string","null"],envLink:"SERVER_RATE_LIMITING_SKIP_TOKEN",description:"Token to bypass the rate limiter, used with `skipKey`",promptOptions:{type:"text"}}},ssl:{enable:{value:!1,types:["boolean"],envLink:"SERVER_SSL_ENABLE",cliName:"enableSsl",description:"Enables or disables SSL protocol",promptOptions:{type:"toggle"}},force:{value:!1,types:["boolean"],envLink:"SERVER_SSL_FORCE",cliName:"sslForce",legacyName:"sslOnly",description:"Forces the server to use HTTPS only when true",promptOptions:{type:"toggle"}},port:{value:443,types:["number"],envLink:"SERVER_SSL_PORT",cliName:"sslPort",description:"Port for the SSL server",promptOptions:{type:"number"}},certPath:{value:null,types:["string","null"],envLink:"SERVER_SSL_CERT_PATH",cliName:"sslCertPath",legacyName:"sslPath",description:"Path to the SSL certificate/key file",promptOptions:{type:"text"}}}},pool:{minWorkers:{value:4,types:["number"],envLink:"POOL_MIN_WORKERS",description:"Minimum and initial number of pool workers to spawn",promptOptions:{type:"number"}},maxWorkers:{value:8,types:["number"],envLink:"POOL_MAX_WORKERS",legacyName:"workers",description:"Maximum number of pool workers to spawn",promptOptions:{type:"number"}},workLimit:{value:40,types:["number"],envLink:"POOL_WORK_LIMIT",description:"Number of tasks a worker can handle before restarting",promptOptions:{type:"number"}},acquireTimeout:{value:5e3,types:["number"],envLink:"POOL_ACQUIRE_TIMEOUT",description:"Timeout in milliseconds for acquiring a resource",promptOptions:{type:"number"}},createTimeout:{value:5e3,types:["number"],envLink:"POOL_CREATE_TIMEOUT",description:"Timeout in milliseconds for creating a resource",promptOptions:{type:"number"}},destroyTimeout:{value:5e3,types:["number"],envLink:"POOL_DESTROY_TIMEOUT",description:"Timeout in milliseconds for destroying a resource",promptOptions:{type:"number"}},idleTimeout:{value:3e4,types:["number"],envLink:"POOL_IDLE_TIMEOUT",description:"Timeout in milliseconds for destroying idle resources",promptOptions:{type:"number"}},createRetryInterval:{value:200,types:["number"],envLink:"POOL_CREATE_RETRY_INTERVAL",description:"Interval in milliseconds before retrying resource creation on failure",promptOptions:{type:"number"}},reaperInterval:{value:1e3,types:["number"],envLink:"POOL_REAPER_INTERVAL",description:"Interval in milliseconds to check and destroy idle resources",promptOptions:{type:"number"}},benchmarking:{value:!1,types:["boolean"],envLink:"POOL_BENCHMARKING",cliName:"poolBenchmarking",description:"Shows statistics for the pool of resources",promptOptions:{type:"toggle"}}},logging:{level:{value:4,types:["number"],envLink:"LOGGING_LEVEL",cliName:"logLevel",description:"Logging verbosity level",promptOptions:{type:"number",round:0,min:0,max:5}},file:{value:"highcharts-export-server.log",types:["string"],envLink:"LOGGING_FILE",cliName:"logFile",description:"Log file name. Requires `logToFile` and `logDest` to be set",promptOptions:{type:"text"}},dest:{value:"log",types:["string"],envLink:"LOGGING_DEST",cliName:"logDest",description:"Path to store log files. Requires `logToFile` to be set",promptOptions:{type:"text"}},toConsole:{value:!0,types:["boolean"],envLink:"LOGGING_TO_CONSOLE",cliName:"logToConsole",description:"Enables or disables console logging",promptOptions:{type:"toggle"}},toFile:{value:!0,types:["boolean"],envLink:"LOGGING_TO_FILE",cliName:"logToFile",description:"Enables or disables logging to a file",promptOptions:{type:"toggle"}}},ui:{enable:{value:!1,types:["boolean"],envLink:"UI_ENABLE",cliName:"enableUi",description:"Enables or disables the UI for the export server",promptOptions:{type:"toggle"}},route:{value:"/",types:["string"],envLink:"UI_ROUTE",cliName:"uiRoute",description:"The endpoint route for the UI",promptOptions:{type:"text"}}},other:{nodeEnv:{value:"production",types:["string"],envLink:"OTHER_NODE_ENV",description:"The Node.js environment type",promptOptions:{type:"text"}},listenToProcessExits:{value:!0,types:["boolean"],envLink:"OTHER_LISTEN_TO_PROCESS_EXITS",description:"Whether or not to attach process.exit handlers",promptOptions:{type:"toggle"}},noLogo:{value:!1,types:["boolean"],envLink:"OTHER_NO_LOGO",description:"Display or skip printing the logo on startup",promptOptions:{type:"toggle"}},hardResetPage:{value:!1,types:["boolean"],envLink:"OTHER_HARD_RESET_PAGE",description:"Whether or not to reset the page content entirely",promptOptions:{type:"toggle"}},browserShellMode:{value:!0,types:["boolean"],envLink:"OTHER_BROWSER_SHELL_MODE",description:"Whether or not to set the browser to run in shell mode",promptOptions:{type:"toggle"}},validation:{value:!0,types:["boolean"],envLink:"OTHER_VALIDATION",description:"Whether or not to enable validation of options types",promptOptions:{type:"toggle"}}},debug:{enable:{value:!1,types:["boolean"],envLink:"DEBUG_ENABLE",cliName:"enableDebug",description:"Enables or disables debug mode for the underlying browser",promptOptions:{type:"toggle"}},headless:{value:!1,types:["boolean"],envLink:"DEBUG_HEADLESS",description:"Whether or not to set the browser to run in headless mode during debugging",promptOptions:{type:"toggle"}},devtools:{value:!1,types:["boolean"],envLink:"DEBUG_DEVTOOLS",description:"Enables or disables DevTools in headful mode",promptOptions:{type:"toggle"}},listenToConsole:{value:!1,types:["boolean"],envLink:"DEBUG_LISTEN_TO_CONSOLE",description:"Enables or disables listening to console messages from the browser",promptOptions:{type:"toggle"}},dumpio:{value:!1,types:["boolean"],envLink:"DEBUG_DUMPIO",description:"Redirects or not browser stdout and stderr to process.stdout and process.stderr",promptOptions:{type:"toggle"}},slowMo:{value:0,types:["number"],envLink:"DEBUG_SLOW_MO",description:"Delays Puppeteer operations by the specified milliseconds",promptOptions:{type:"number"}},debuggingPort:{value:9222,types:["number"],envLink:"DEBUG_DEBUGGING_PORT",description:"Port used for debugging",promptOptions:{type:"number"}}}};dotenv.config();const{coreScripts:coreScripts,moduleScripts:moduleScripts,indicatorScripts:indicatorScripts}=defaultConfig.highcharts;z.setErrorMap(_customErrorMap);const v={boolean:e=>e?z.boolean():z.union([z.enum(["true","1","false","0","undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:"true"===e||"1"===e)),z.boolean()]).nullable(),string:e=>e?z.string().trim().refine((e=>!["false","undefined","null",""].includes(e)),{params:{errorMessage:"The string contains a forbidden value"}}):z.string().trim().transform((e=>["false","undefined","null",""].includes(e)?null:e)).nullable(),enum:(e,t)=>t?z.enum([...e]):z.enum([...e,"undefined","null",""]).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),stringArray(e,t,o){const r=z.string().trim().array(),i=z.string().trim().transform((e=>(e.startsWith("[")&&(e=e.slice(1)),e.endsWith("]")&&(e=e.slice(0,-1)),e.split(t)))),n=t=>t.map((e=>e.trim())).filter(e);return o?r.transform(n):z.union([i,r]).transform(n).transform((e=>e.length?e:null)).nullable()},positiveNum:e=>e?z.number().positive():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and positive"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().positive()]).nullable(),nonNegativeNum:e=>e?z.number().nonnegative():z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&Number(e)>=0||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be numeric and non-negative"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().nonnegative()]).nullable(),startsWith:(e,t)=>t?z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}):z.string().trim().refine((t=>e.some((e=>t.startsWith(e)))||["undefined","null",""].includes(t)),{params:{errorMessage:`The value must be a string that starts with ${e.join(", ")}`}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),chartConfig:()=>z.union([z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable(),additionalOptions:()=>z.union([z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.startsWith("{")&&e.endsWith("}")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with '.json' or starts with '{' and ends with '}'"}}).transform((e=>["undefined","null",""].includes(e)?null:e)),z.object({}).passthrough()]).nullable()},validators={args:e=>v.stringArray((e=>!["false","undefined","null",""].includes(e)),";",e),version:e=>e?z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}):z.string().trim().refine((e=>/^(latest|\d{1,2}(\.\d{1,2}){0,2})$/.test(e)||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be 'latest', a major version, or in the form XX.YY.ZZ"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),cdnUrl:e=>v.startsWith(["http://","https://"],e),forceFetch:e=>v.boolean(e),cachePath:e=>v.string(e),adminToken:e=>v.string(e),coreScripts:e=>v.stringArray((e=>coreScripts.value.includes(e)),",",e),moduleScripts:e=>v.stringArray((e=>moduleScripts.value.includes(e)),",",e),indicatorScripts:e=>v.stringArray((e=>indicatorScripts.value.includes(e)),",",e),customScripts:e=>v.stringArray((e=>e.startsWith("https://")||e.startsWith("http://")),",",e),infile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".json")||e.length>=5&&e.endsWith(".svg")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),instr:()=>v.chartConfig(),options:()=>v.chartConfig(),svg:()=>z.string().trim().refine((e=>e.indexOf("=0||e.indexOf("=0||["false","undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that contains '["false","undefined","null",""].includes(e)?null:e)).nullable(),outfile:e=>e?z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).nullable():z.string().trim().refine((e=>e.length>=6&&e.endsWith(".jpeg")||e.length>=5&&(e.endsWith(".jpg")||e.endsWith(".png")||e.endsWith(".pdf")||e.endsWith(".svg"))||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg"}}).transform((e=>["undefined","null",""].includes(e)?null:e)).nullable(),type:e=>v.enum(["jpeg","jpg","png","pdf","svg"],e),constr:e=>v.enum(["chart","stockChart","mapChart","ganttChart"],e),b64:e=>v.boolean(e),noDownload:e=>v.boolean(e),defaultHeight:e=>v.positiveNum(e),defaultWidth:e=>v.positiveNum(e),defaultScale:e=>e?z.number().gte(.1).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number(e)>=.1&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0.1 and 5.0 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().gte(.1).lte(5)]).nullable(),height(e){return this.defaultHeight(e).nullable()},width(e){return this.defaultWidth(e).nullable()},scale(e){return this.defaultScale(e).nullable()},globalOptions:()=>v.additionalOptions(),themeOptions:()=>v.additionalOptions(),batch:e=>v.string(e),rasterizationTimeout:e=>v.nonNegativeNum(e),allowCodeExecution:e=>v.boolean(e),allowFileResources:e=>v.boolean(e),customCode:e=>v.string(e),callback:e=>v.string(e),resources(e){const t=z.object({js:v.string(!1),css:v.string(!1),files:v.stringArray((e=>!["undefined","null",""].includes(e)),",",!0).nullable()}).partial(),o=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that starts with '{' and ends with '}"}}),r=z.string().trim().refine((e=>e.startsWith("{")&&e.endsWith("}")||e.length>=6&&e.endsWith(".json")||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be a string that ends with .json"}}).transform((e=>["undefined","null",""].includes(e)?null:e));return e?z.union([t,o]).nullable():z.union([t,r]).nullable()},loadConfig:e=>v.string(e).refine((e=>null===e||e.length>=6&&e.endsWith(".json")),{params:{errorMessage:"The value must be a string that ends with .json"}}),createConfig(e){return this.loadConfig(e)},enableServer:e=>v.boolean(e),host:e=>v.string(e),port:e=>v.nonNegativeNum(e),uploadLimit:e=>v.positiveNum(e),serverBenchmarking:e=>v.boolean(e),proxyHost:e=>v.string(e),proxyPort:e=>v.nonNegativeNum(e).nullable(),proxyTimeout:e=>v.nonNegativeNum(e),enableRateLimiting:e=>v.boolean(e),maxRequests:e=>v.nonNegativeNum(e),window:e=>v.nonNegativeNum(e),delay:e=>v.nonNegativeNum(e),trustProxy:e=>v.boolean(e),skipKey:e=>v.string(e),skipToken:e=>v.string(e),enableSsl:e=>v.boolean(e),sslForce:e=>v.boolean(e),sslPort:e=>v.nonNegativeNum(e),sslCertPath:e=>v.string(e),minWorkers:e=>v.positiveNum(e),maxWorkers:e=>v.positiveNum(e),workLimit:e=>v.positiveNum(e),acquireTimeout:e=>v.nonNegativeNum(e),createTimeout:e=>v.nonNegativeNum(e),destroyTimeout:e=>v.nonNegativeNum(e),idleTimeout:e=>v.nonNegativeNum(e),createRetryInterval:e=>v.nonNegativeNum(e),reaperInterval:e=>v.nonNegativeNum(e),poolBenchmarking:e=>v.boolean(e),resourcesInterval:e=>v.nonNegativeNum(e),logLevel:e=>e?z.number().int().gte(0).lte(5):z.union([z.string().trim().refine((e=>!isNaN(Number(e))&&!0!==e&&!e.startsWith("[")&&Number.isInteger(Number(e))&&Number(e)>=0&&Number(e)<=5||["undefined","null",""].includes(e)),{params:{errorMessage:"The value must be within a 0 and 5 range"}}).transform((e=>["undefined","null",""].includes(e)?null:Number(e))),z.number().int().gte(0).lte(5)]).nullable(),logFile:e=>v.string(e).refine((e=>null===e||e.length>=5&&e.endsWith(".log")),{params:{errorMessage:"The value must be a string that ends with .log"}}),logDest:e=>v.string(e),logToConsole:e=>v.boolean(e),logToFile:e=>v.boolean(e),enableUi:e=>v.boolean(e),uiRoute:e=>v.startsWith(["/"],e),nodeEnv:e=>v.enum(["development","production","test"],e),listenToProcessExits:e=>v.boolean(e),noLogo:e=>v.boolean(e),hardResetPage:e=>v.boolean(e),browserShellMode:e=>v.boolean(e),validation:e=>v.boolean(e),enableDebug:e=>v.boolean(e),headless:e=>v.boolean(e),devtools:e=>v.boolean(e),listenToConsole:e=>v.boolean(e),dumpio:e=>v.boolean(e),slowMo:e=>v.nonNegativeNum(e),debuggingPort:e=>v.nonNegativeNum(e),requestId:()=>z.string().uuid({message:"The value must be a stringified UUID"}).nullable()},PuppeteerSchema=e=>z.object({args:validators.args(e)}).partial(),HighchartsSchema=e=>z.object({version:validators.version(e),cdnUrl:validators.cdnUrl(e),forceFetch:validators.forceFetch(e),cachePath:validators.cachePath(e),coreScripts:validators.coreScripts(e),moduleScripts:validators.moduleScripts(e),indicatorScripts:validators.indicatorScripts(e),customScripts:validators.customScripts(e)}).partial(),ExportSchema=e=>z.object({infile:validators.infile(e),instr:validators.instr(),options:validators.options(),svg:validators.svg(),outfile:validators.outfile(e),type:validators.type(e),constr:validators.constr(e),b64:validators.b64(e),noDownload:validators.noDownload(e),defaultHeight:validators.defaultHeight(e),defaultWidth:validators.defaultWidth(e),defaultScale:validators.defaultScale(e),height:validators.height(e),width:validators.width(e),scale:validators.scale(e),globalOptions:validators.globalOptions(),themeOptions:validators.themeOptions(),batch:validators.batch(!1),rasterizationTimeout:validators.rasterizationTimeout(e)}).partial(),CustomLogicSchema=e=>z.object({allowCodeExecution:validators.allowCodeExecution(e),allowFileResources:validators.allowFileResources(e),customCode:validators.customCode(!1),callback:validators.callback(!1),resources:validators.resources(e),loadConfig:validators.loadConfig(!1),createConfig:validators.createConfig(!1)}).partial(),ProxySchema=e=>z.object({host:validators.proxyHost(!1),port:validators.proxyPort(e),timeout:validators.proxyTimeout(e)}).partial(),RateLimitingSchema=e=>z.object({enable:validators.enableRateLimiting(e),maxRequests:validators.maxRequests(e),window:validators.window(e),delay:validators.delay(e),trustProxy:validators.trustProxy(e),skipKey:validators.skipKey(!1),skipToken:validators.skipToken(!1)}).partial(),SslSchema=e=>z.object({enable:validators.enableSsl(e),force:validators.sslForce(e),port:validators.sslPort(e),certPath:validators.sslCertPath(!1)}).partial(),ServerSchema=e=>z.object({enable:validators.enableServer(e).optional(),host:validators.host(e).optional(),port:validators.port(e).optional(),uploadLimit:validators.uploadLimit(e).optional(),benchmarking:validators.serverBenchmarking(e).optional(),proxy:ProxySchema(e).optional(),rateLimiting:RateLimitingSchema(e).optional(),ssl:SslSchema(e).optional()}),PoolSchema=e=>z.object({minWorkers:validators.minWorkers(e),maxWorkers:validators.maxWorkers(e),workLimit:validators.workLimit(e),acquireTimeout:validators.acquireTimeout(e),createTimeout:validators.createTimeout(e),destroyTimeout:validators.destroyTimeout(e),idleTimeout:validators.idleTimeout(e),createRetryInterval:validators.createRetryInterval(e),reaperInterval:validators.reaperInterval(e),benchmarking:validators.poolBenchmarking(e)}).partial(),LoggingSchema=e=>z.object({level:validators.logLevel(e),file:validators.logFile(e),dest:validators.logDest(e),toConsole:validators.logToConsole(e),toFile:validators.logToFile(e)}).partial(),UiSchema=e=>z.object({enable:validators.enableUi(e),route:validators.uiRoute(e)}).partial(),OtherSchema=e=>z.object({nodeEnv:validators.nodeEnv(e),listenToProcessExits:validators.listenToProcessExits(e),noLogo:validators.noLogo(e),hardResetPage:validators.hardResetPage(e),browserShellMode:validators.browserShellMode(e),validation:validators.validation(e)}).partial(),DebugSchema=e=>z.object({enable:validators.enableDebug(e),headless:validators.headless(e),devtools:validators.devtools(e),listenToConsole:validators.listenToConsole(e),dumpio:validators.dumpio(e),slowMo:validators.slowMo(e),debuggingPort:validators.debuggingPort(e)}).partial(),StrictConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!0),highcharts:HighchartsSchema(!0),export:ExportSchema(!0),customLogic:CustomLogicSchema(!0),server:ServerSchema(!0),pool:PoolSchema(!0),logging:LoggingSchema(!0),ui:UiSchema(!0),other:OtherSchema(!0),debug:DebugSchema(!0)}),LooseConfigSchema=z.object({requestId:validators.requestId(),puppeteer:PuppeteerSchema(!1),highcharts:HighchartsSchema(!1),export:ExportSchema(!1),customLogic:CustomLogicSchema(!1),server:ServerSchema(!1),pool:PoolSchema(!1),logging:LoggingSchema(!1),ui:UiSchema(!1),other:OtherSchema(!1),debug:DebugSchema(!1)}),EnvSchema=z.object({PUPPETEER_ARGS:validators.args(!1),HIGHCHARTS_VERSION:validators.version(!1),HIGHCHARTS_CDN_URL:validators.cdnUrl(!1),HIGHCHARTS_FORCE_FETCH:validators.forceFetch(!1),HIGHCHARTS_CACHE_PATH:validators.cachePath(!1),HIGHCHARTS_ADMIN_TOKEN:validators.adminToken(!1),HIGHCHARTS_CORE_SCRIPTS:validators.coreScripts(!1),HIGHCHARTS_MODULE_SCRIPTS:validators.moduleScripts(!1),HIGHCHARTS_INDICATOR_SCRIPTS:validators.indicatorScripts(!1),HIGHCHARTS_CUSTOM_SCRIPTS:validators.customScripts(!1),EXPORT_INFILE:validators.infile(!1),EXPORT_INSTR:validators.instr(),EXPORT_OPTIONS:validators.options(),EXPORT_SVG:validators.svg(),EXPORT_BATCH:validators.batch(!1),EXPORT_OUTFILE:validators.outfile(!1),EXPORT_TYPE:validators.type(!1),EXPORT_CONSTR:validators.constr(!1),EXPORT_B64:validators.b64(!1),EXPORT_NO_DOWNLOAD:validators.noDownload(!1),EXPORT_HEIGHT:validators.height(!1),EXPORT_WIDTH:validators.width(!1),EXPORT_SCALE:validators.scale(!1),EXPORT_DEFAULT_HEIGHT:validators.defaultHeight(!1),EXPORT_DEFAULT_WIDTH:validators.defaultWidth(!1),EXPORT_DEFAULT_SCALE:validators.defaultScale(!1),EXPORT_GLOBAL_OPTIONS:validators.globalOptions(),EXPORT_THEME_OPTIONS:validators.themeOptions(),EXPORT_RASTERIZATION_TIMEOUT:validators.rasterizationTimeout(!1),CUSTOM_LOGIC_ALLOW_CODE_EXECUTION:validators.allowCodeExecution(!1),CUSTOM_LOGIC_ALLOW_FILE_RESOURCES:validators.allowFileResources(!1),CUSTOM_LOGIC_CUSTOM_CODE:validators.customCode(!1),CUSTOM_LOGIC_CALLBACK:validators.callback(!1),CUSTOM_LOGIC_RESOURCES:validators.resources(!1),CUSTOM_LOGIC_LOAD_CONFIG:validators.loadConfig(!1),CUSTOM_LOGIC_CREATE_CONFIG:validators.createConfig(!1),SERVER_ENABLE:validators.enableServer(!1),SERVER_HOST:validators.host(!1),SERVER_PORT:validators.port(!1),SERVER_UPLOAD_LIMIT:validators.uploadLimit(!1),SERVER_BENCHMARKING:validators.serverBenchmarking(!1),SERVER_PROXY_HOST:validators.proxyHost(!1),SERVER_PROXY_PORT:validators.proxyPort(!1),SERVER_PROXY_TIMEOUT:validators.proxyTimeout(!1),SERVER_RATE_LIMITING_ENABLE:validators.enableRateLimiting(!1),SERVER_RATE_LIMITING_MAX_REQUESTS:validators.maxRequests(!1),SERVER_RATE_LIMITING_WINDOW:validators.window(!1),SERVER_RATE_LIMITING_DELAY:validators.delay(!1),SERVER_RATE_LIMITING_TRUST_PROXY:validators.trustProxy(!1),SERVER_RATE_LIMITING_SKIP_KEY:validators.skipKey(!1),SERVER_RATE_LIMITING_SKIP_TOKEN:validators.skipToken(!1),SERVER_SSL_ENABLE:validators.enableSsl(!1),SERVER_SSL_FORCE:validators.sslForce(!1),SERVER_SSL_PORT:validators.sslPort(!1),SERVER_SSL_CERT_PATH:validators.sslCertPath(!1),POOL_MIN_WORKERS:validators.minWorkers(!1),POOL_MAX_WORKERS:validators.maxWorkers(!1),POOL_WORK_LIMIT:validators.workLimit(!1),POOL_ACQUIRE_TIMEOUT:validators.acquireTimeout(!1),POOL_CREATE_TIMEOUT:validators.createTimeout(!1),POOL_DESTROY_TIMEOUT:validators.destroyTimeout(!1),POOL_IDLE_TIMEOUT:validators.idleTimeout(!1),POOL_CREATE_RETRY_INTERVAL:validators.createRetryInterval(!1),POOL_REAPER_INTERVAL:validators.reaperInterval(!1),POOL_BENCHMARKING:validators.poolBenchmarking(!1),LOGGING_LEVEL:validators.logLevel(!1),LOGGING_FILE:validators.logFile(!1),LOGGING_DEST:validators.logDest(!1),LOGGING_TO_CONSOLE:validators.logToConsole(!1),LOGGING_TO_FILE:validators.logToFile(!1),UI_ENABLE:validators.enableUi(!1),UI_ROUTE:validators.uiRoute(!1),OTHER_NODE_ENV:validators.nodeEnv(!1),OTHER_LISTEN_TO_PROCESS_EXITS:validators.listenToProcessExits(!1),OTHER_NO_LOGO:validators.noLogo(!1),OTHER_HARD_RESET_PAGE:validators.hardResetPage(!1),OTHER_BROWSER_SHELL_MODE:validators.browserShellMode(!1),OTHER_VALIDATION:validators.validation(!1),DEBUG_ENABLE:validators.enableDebug(!1),DEBUG_HEADLESS:validators.headless(!1),DEBUG_DEVTOOLS:validators.devtools(!1),DEBUG_LISTEN_TO_CONSOLE:validators.listenToConsole(!1),DEBUG_DUMPIO:validators.dumpio(!1),DEBUG_SLOW_MO:validators.slowMo(!1),DEBUG_DEBUGGING_PORT:validators.debuggingPort(!1)}),envs=EnvSchema.partial().parse(process.env);function strictValidate(e){return StrictConfigSchema.partial().parse(e)}function looseValidate(e){return LooseConfigSchema.partial().parse(e)}function _customErrorMap(e,t){const o=e.path.join("."),r=`Invalid value for the ${o}`;if(e.code===z.ZodIssueCode.invalid_type)return e.received===z.ZodParsedType.undefined?{message:`${r} - No value was provided.`}:{message:`${r} - Invalid type. ${t.defaultError}.`};if(e.code===z.ZodIssueCode.custom&&e.params?.errorMessage)return{message:`${r} - ${e.params?.errorMessage}, received '${t.data}'.`};if(e.code===z.ZodIssueCode.invalid_union){let t=`Multiple errors occurred for the ${o}:\n`;return e.unionErrors.forEach((e=>{const o=e.issues[0].message.indexOf("-");t+=-1!==o?`${e.issues[0].message}\n`.substring(o):`${e.issues[0].message}\n`})),{message:t}}return{message:`${r} - ${t.defaultError}.`}}class ExportError extends Error{constructor(e,t){super(),this.message=e,this.stackMessage=e,t&&(this.statusCode=t)}setError(e){return this.error=e,e.name&&(this.name=e.name),e.statusCode&&(this.statusCode=e.statusCode),e.stack&&(this.stackMessage=e.message,this.stack=e.stack),this}}const globalOptions=_initOptions(defaultConfig),nestedProps=_createNestedProps(defaultConfig),absoluteProps=_createAbsoluteProps(defaultConfig);function getOptions(e=!0){return e?deepCopy(globalOptions):globalOptions}function updateOptions(e,t=!1,o=!0){return _mergeOptions(getOptions(t),validateOptions(e,o))}function mapToNewOptions(e){const t={};if(isObject(e))for(const[o,r]of Object.entries(e)){const e=nestedProps[o]?nestedProps[o].split("."):[];e.reduce(((t,o,i)=>t[o]=e.length-1===i?r:t[o]||{}),t)}else log(2,"[config] No correct object with options was provided. Returning an empty object.");return t}function validateOption(e,t,o=!0){if(!getOptions().other.validation)return t;try{return validators[e](o).parse(t)}catch(t){throw logZodIssues(1,t.issues,`[validation] The ${e} option validation error`),new ExportError(`[validation] The ${e} option validation error`,400)}}function validateOptions(e,t=!0){if(!getOptions().other.validation)return e;try{return t?strictValidate(e):looseValidate(e)}catch(e){throw logZodIssues(1,e.issues,"[validation] Options validation error"),new ExportError("[validation] Options validation error",400)}}function isAllowedConfig(config,toString=!1,allowFunctions=!1){try{if(!isObject(config)&&"string"!=typeof config)return null;const objectConfig="string"==typeof config?allowFunctions?eval(`(${config})`):JSON.parse(config):config,stringifiedOptions=_optionsStringify(objectConfig,allowFunctions,!1),parsedOptions=allowFunctions?JSON.parse(_optionsStringify(objectConfig,allowFunctions,!0),((_,value)=>"string"==typeof value&&value.startsWith("function")?eval(`(${value})`):value)):JSON.parse(stringifiedOptions);return toString?stringifiedOptions:parsedOptions}catch(e){return null}}function _initOptions(e){const t={};for(const[o,r]of Object.entries(e))Object.prototype.hasOwnProperty.call(r,"value")?void 0!==envs[r.envLink]&&null!==envs[r.envLink]?t[o]=envs[r.envLink]:t[o]=r.value:t[o]=_initOptions(r);return t}function _mergeOptions(e,t){if(isObject(e)&&isObject(t))for(const[o,r]of Object.entries(t))e[o]=isObject(r)&&!absoluteProps.includes(o)&&void 0!==e[o]?_mergeOptions(e[o],r):void 0!==r?r:e[o]||null;return e}function _optionsStringify(e,t,o){return JSON.stringify(e,((e,r)=>{if("string"==typeof r&&(r=r.trim()),"function"==typeof r||"string"==typeof r&&r.startsWith("function")&&r.endsWith("}")){if(t)return o?`"EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN"`:`EXP_FUN${(r+"").replaceAll(/\s+/g," ")}EXP_FUN`;throw new Error}return r})).replaceAll(o?/\\"EXP_FUN|EXP_FUN\\"/g:/"EXP_FUN|EXP_FUN"/g,"")}function _createNestedProps(e,t={},o=""){return Object.keys(e).forEach((r=>{const i=e[r];void 0===i.value?_createNestedProps(i,t,`${o}.${r}`):(t[i.cliName||r]=`${o}.${r}`.substring(1),void 0!==i.legacyName&&(t[i.legacyName]=`${o}.${r}`.substring(1)))})),t}function _createAbsoluteProps(e,t=[]){return Object.keys(e).forEach((o=>{const r=e[o];void 0===r.types?_createAbsoluteProps(r,t):r.types.includes("Object")&&t.push(o)})),t}async function get$1(e,t={}){return new Promise(((o,r)=>{_getProtocolModule(e).get(e,t,(e=>{let t="";e.on("data",(e=>{t+=e})),e.on("end",(()=>{t||r("Nothing was fetched from the URL."),e.text=t,o(e)}))})).on("error",(e=>{r(e)}))}))}function _getProtocolModule(e){return e.startsWith("https")?https:http}const cache={cdnUrl:"https://code.highcharts.com",activeManifest:{},sources:"",hcVersion:""};async function checkCache(e,t){try{let o;const r=getCachePath(),i=join(r,"manifest.json"),n=join(r,"sources.js");if(!existsSync(r)&&mkdirSync(r,{recursive:!0}),!existsSync(i)||e.forceFetch)log(3,"[cache] Fetching and caching Highcharts dependencies."),o=await _updateCache(e,t,n);else{let r=!1;const s=JSON.parse(readFileSync(i),"utf8");if(s.modules&&Array.isArray(s.modules)){const e={};s.modules.forEach((t=>e[t]=1)),s.modules=e}const{coreScripts:a,moduleScripts:l,indicatorScripts:c}=e,p=a.length+l.length+c.length;s.version!==e.version?(log(2,"[cache] A Highcharts version mismatch in the cache, need to re-fetch."),r=!0):Object.keys(s.modules||{}).length!==p?(log(2,"[cache] The cache and the requested modules do not match, need to re-fetch."),r=!0):r=(l||[]).some((e=>{if(!s.modules[e])return log(2,`[cache] The ${e} is missing in the cache, need to re-fetch.`),!0})),r?o=await _updateCache(e,t,n):(log(3,"[cache] Dependency cache is up to date, proceeding."),cache.sources=readFileSync(n,"utf8"),o=s.modules,cache.hcVersion=_extractHcVersion(cache.sources))}await _saveConfigToManifest(e.version,o)}catch(e){throw new ExportError("[cache] Could not configure cache and create or update the config manifest.",500).setError(e)}}function getHcVersion(){return cache.hcVersion}async function updateHcVersion(e){const t=updateOptions({highcharts:{version:e}});await checkCache(t.highcharts,t.server.proxy)}function getCachePath(){return getAbsolutePath(getOptions().highcharts.cachePath)}async function _saveConfigToManifest(e,t={}){cache.activeManifest={version:e,modules:t},log(3,"[cache] Writing a new manifest.");try{writeFileSync(join(getCachePath(),"manifest.json"),JSON.stringify(cache.activeManifest),"utf8")}catch(e){throw new ExportError("[cache] Error writing the cache manifest.",500).setError(e)}}async function _updateCache(e,t,o){try{const r="latest"===e.version?null:`${e.version}`;log(3,`[cache] Updating cache version to Highcharts: ${r||"latest"}.`);const i=e.cdnUrl||cache.cdnUrl,n=_configureRequest(t),s={};return cache.sources=(await Promise.all([...e.coreScripts.map((e=>_fetchScript(r?`${i}/${r}/${e}`:`${i}/${e}`,n,s,!0))),...e.moduleScripts.map((e=>_fetchScript("map"===e?r?`${i}/maps/${r}/modules/${e}`:`${i}/maps/modules/${e}`:r?`${i}/${r}/modules/${e}`:`${i}/modules/${e}`,n,s))),...e.indicatorScripts.map((e=>_fetchScript(r?`${i}/stock/${r}/indicators/${e}`:`${i}/stock/indicators/${e}`,n,s))),...e.customScripts.map((e=>_fetchScript(`${e}`,n)))])).join(";\n"),cache.hcVersion=_extractHcVersion(cache.sources),writeFileSync(o,cache.sources),s}catch(e){throw new ExportError("[cache] Unable to update the local Highcharts cache.",500).setError(e)}}async function _fetchScript(e,t,o,r=!1){e.endsWith(".js")&&(e=e.substring(0,e.length-3)),log(4,`[cache] Fetching script - ${e}.js`);const i=await get$1(`${e}.js`,t);if(200===i.statusCode&&"string"==typeof i.text){if(o){o[_extractModuleName(e)]=1}return i.text}if(r)throw new ExportError(`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version (status code: ${i.statusCode}).`,404).setError(i);log(2,`[cache] Could not fetch the ${e}.js. The script might not exist in the requested version.`)}function _configureRequest(e){const t=e.host,o=e.port;if(t&&o)try{return{agent:new HttpsProxyAgent({host:t,port:o}),timeout:e.timeout}}catch(e){throw new ExportError("[cache] Could not create a Proxy Agent.",500).setError(e)}return{}}function _extractHcVersion(e){return e.substring(0,e.indexOf("*/")).replace("/*","").replace("*/","").replace(/\n/g,"").trim()}function _extractModuleName(e){return e.replace(/(.*)\/|(.*)modules\/|stock\/(.*)indicators\/|maps\/(.*)modules\//gi,"")}function setupHighcharts(){Highcharts.animObject=function(){return{duration:0}}}async function createChart(e,t){const{getOptions:o,setOptions:r,merge:i,wrap:n}=Highcharts;Highcharts.setOptionsObj=i(!1,{},o()),window.isRenderComplete=!1,n(Highcharts.Chart.prototype,"init",(function(e,t,o){((t=i(t,{exporting:{enabled:!1},plotOptions:{series:{label:{enabled:!1}}},tooltip:{}})).series||[]).forEach((function(e){e.animation=!1})),window.onHighchartsRender||(window.onHighchartsRender=Highcharts.addEvent(this,"render",(()=>{window.isRenderComplete=!0}))),e.apply(this,[t,o])})),n(Highcharts.Series.prototype,"init",(function(e,t,o){e.apply(this,[t,o])}));const s={chart:{animation:!1,height:e.height,width:e.width},exporting:{enabled:!1}},a=new Function(`return ${e.instr}`)(),l=new Function(`return ${e.themeOptions}`)(),c=i(!1,l,a,s),p=t.callback?new Function(`return ${t.callback}`)():null;t.customCode&&new Function("options",t.customCode)(a);const u=new Function(`return ${e.globalOptions}`)();u&&r(u),Highcharts[e.constr]("container",c,p);const d=Array.from(document.querySelectorAll(".highcharts-container image"));await Promise.race([Promise.all(d.map((e=>e.complete&&0!==e.naturalHeight?Promise.resolve():new Promise((t=>e.addEventListener("load",t,{once:!0})))))),new Promise((e=>setTimeout(e,2e3)))]);const g=o();for(const e in g)"function"!=typeof g[e]&&delete g[e];r(Highcharts.setOptionsObj),Highcharts.setOptionsObj={}}const pageTemplate=readFileSync(join(__dirname,"templates","template.html"),"utf8");let browser=null;async function createBrowser(e){const{debug:t,other:o}=getOptions(),{enable:r,...i}=t,n={headless:!o.browserShellMode||"shell",userDataDir:"tmp",args:e||[],handleSIGINT:!1,handleSIGTERM:!1,handleSIGHUP:!1,waitForInitialPage:!1,defaultViewport:null,...r&&i};if(!browser){let e=0;const t=async()=>{try{log(3,`[browser] Attempting to launch and get a browser instance (try ${++e}).`),browser=await puppeteer.launch(n)}catch(o){if(logWithStack(1,o,"[browser] Failed to launch a browser instance."),!(e<25))throw o;log(3,`[browser] Retry to open a browser (${e} out of 25).`),await new Promise((e=>setTimeout(e,4e3))),await t()}};try{await t(),"shell"===n.headless&&log(3,"[browser] Launched browser in shell mode."),r&&log(3,"[browser] Launched browser in debug mode.")}catch(e){throw new ExportError("[browser] Maximum retries to open a browser instance reached.",500).setError(e)}if(!browser)throw new ExportError("[browser] Cannot find a browser to open.",500)}return browser}async function closeBrowser(){browser&&browser.connected&&await browser.close(),browser=null,log(4,"[browser] Closed the browser.")}async function newPage(e){if(!browser||!browser.connected)throw new ExportError("[browser] Browser is not yet connected.",500);if(e.page=await browser.newPage(),await e.page.setCacheEnabled(!1),await _setPageContent(e.page),_setPageEvents(e.page),!e.page||e.page.isClosed())throw new ExportError("[browser] The page is invalid or closed.",400)}async function clearPage(e,t=!1){try{if(e.page&&!e.page.isClosed())return t?(await e.page.goto("about:blank",{waitUntil:"domcontentloaded"}),await _setPageContent(e.page)):await e.page.evaluate((()=>{document.body.innerHTML='
'})),!0}catch(t){logWithStack(2,t,`[pool] Pool resource [${e.id}] - Content of the page could not be cleared.`),e.workCount=getOptions().pool.workLimit+1}return!1}async function addPageResources(e,t){const o=[],r=t.resources;if(r){const i=[];if(r.js&&i.push({content:r.js}),r.files)for(const e of r.files){const t=!e.startsWith("http");i.push(t?{content:readFileSync(getAbsolutePath(e),"utf8")}:{url:e})}for(const t of i)try{o.push(await e.addScriptTag(t))}catch(e){logWithStack(2,e,"[browser] The JS resource cannot be loaded.")}i.length=0;const n=[];if(r.css){const i=r.css.match(/@import\s*([^;]*);/g);if(i)for(let e of i)e&&(e=e.replace("url(","").replace("@import","").replace(/"/g,"").replace(/'/g,"").replace(/;/,"").replace(/\)/g,"").trim(),e.startsWith("http")?n.push({url:e}):t.allowFileResources&&n.push({path:getAbsolutePath(e)}));n.push({content:r.css.replace(/@import\s*([^;]*);/g,"")||" "});for(const t of n)try{o.push(await e.addStyleTag(t))}catch(e){logWithStack(2,e,"[browser] The CSS resource cannot be loaded.")}n.length=0}}return o}async function clearPageResources(e,t){try{for(const e of t)await e.dispose();await e.evaluate((()=>{if("undefined"!=typeof Highcharts){const e=Highcharts.charts;if(Array.isArray(e)&&e.length)for(const t of e)t&&t.destroy(),Highcharts.charts.shift()}const[...e]=document.getElementsByTagName("script"),[,...t]=document.getElementsByTagName("style"),[...o]=document.getElementsByTagName("link");for(const r of[...e,...t,...o])r.remove()}))}catch(e){logWithStack(2,e,"[browser] Could not clear page's resources.")}}async function _setPageContent(e){await e.setContent(pageTemplate,{waitUntil:"domcontentloaded"}),await e.addScriptTag({path:join(getCachePath(),"sources.js")}),await e.evaluate(setupHighcharts)}function _setPageEvents(e){const{debug:t}=getOptions();e.on("pageerror",(async()=>{e.isClosed()})),t.enable&&t.listenToConsole&&e.on("console",(e=>{console.log(`[debug] ${e.text()}`)}))}var cssTemplate=()=>"\n\nhtml, body {\n margin: 0;\n padding: 0;\n box-sizing: border-box;\n}\n\n#table-div, #sliders, #datatable, #controls, .ld-row {\n display: none;\n height: 0;\n}\n\n#chart-container {\n box-sizing: border-box;\n margin: 0;\n overflow: auto;\n font-size: 0;\n}\n\n#chart-container > figure, div {\n margin-top: 0 !important;\n margin-bottom: 0 !important;\n}\n\n",svgTemplate=e=>`\n\n\n \n \n Highcharts Export\n \n \n \n
\n ${e}\n
\n \n\n\n`;async function puppeteerExport(e,t,o){const r=[];try{let i=!1;if(t.svg){if(log(4,"[export] Treating as SVG input."),"svg"===t.type)return t.svg;i=!0,await e.setContent(svgTemplate(t.svg),{waitUntil:"domcontentloaded"})}else log(4,"[export] Treating as JSON config."),await e.evaluate(createChart,t,o);r.push(...await addPageResources(e,o));const n=await _getChartSize(e,i,t.scale),{x:s,y:a}=await _getClipRegion(e),l=Math.abs(Math.ceil(n.chartHeight||t.height)),c=Math.abs(Math.ceil(n.chartWidth||t.width));let p;switch(await e.setViewport({height:l,width:c,deviceScaleFactor:i?1:parseFloat(t.scale)}),t.type){case"svg":p=await _createSVG(e);break;case"png":case"jpeg":p=await _createImage(e,t.type,{width:c,height:l,x:s,y:a},t.rasterizationTimeout);break;case"pdf":p=await _createPDF(e,l,c,t.rasterizationTimeout);break;default:throw new ExportError(`[export] Unsupported output format: ${t.type}.`,400)}return await clearPageResources(e,r),p}catch(t){return await clearPageResources(e,r),t}}async function _getClipRegion(e){return e.$eval("#chart-container",(e=>{const{x:t,y:o,width:r,height:i}=e.getBoundingClientRect();return{x:t,y:o,width:r,height:Math.trunc(i>1?i:500)}}))}async function _getChartSize(e,t,o){return t?await e.evaluate((e=>{const t=document.querySelector("#chart-container svg:first-of-type"),o=t.height.baseVal.value*e,r=t.width.baseVal.value*e;return document.body.style.zoom=e,document.body.style.margin="0px",{chartHeight:o,chartWidth:r}}),parseFloat(o)):await e.evaluate((()=>{const{chartHeight:e,chartWidth:t}=window.Highcharts.charts[0];return document.body.style.zoom=1,{chartHeight:e,chartWidth:t}}))}async function _createSVG(e){return e.$eval("#container svg:first-of-type",(e=>e.outerHTML))}async function _createImage(e,t,o,r){return Promise.race([e.screenshot({type:t,clip:o,encoding:"base64",fullPage:!1,optimizeForSpeed:!0,captureBeyondViewport:!0,..."png"!==t?{quality:80}:{},omitBackground:"png"==t}),new Promise(((e,t)=>setTimeout((()=>t(new ExportError("Rasterization timeout",408))),r||1500)))])}async function _createPDF(e,t,o,r){return await e.emulateMediaType("screen"),e.pdf({height:t+1,width:o,encoding:"base64",timeout:r||1500})}let pool=null;const poolStats={exportsAttempted:0,exportsPerformed:0,exportsDropped:0,exportsFromSvg:0,exportsFromOptions:0,exportsFromSvgAttempts:0,exportsFromOptionsAttempts:0,timeSpent:0,timeSpentAverage:0};async function initPool(e,t){await createBrowser(t);try{if(log(3,`[pool] Initializing pool with workers: min ${e.minWorkers}, max ${e.maxWorkers}.`),pool)return void log(4,"[pool] Already initialized, please kill it before creating a new one.");e.minWorkers>e.maxWorkers&&(e.minWorkers=e.maxWorkers),pool=new Pool({..._factory(e),min:e.minWorkers,max:e.maxWorkers,acquireTimeoutMillis:e.acquireTimeout,createTimeoutMillis:e.createTimeout,destroyTimeoutMillis:e.destroyTimeout,idleTimeoutMillis:e.idleTimeout,createRetryIntervalMillis:e.createRetryInterval,reapIntervalMillis:e.reaperInterval,propagateCreateError:!1}),pool.on("release",(async e=>{const t=await clearPage(e,!1);log(4,`[pool] Pool resource [${e.id}] - Releasing a worker. Clear page status: ${t}.`)})),pool.on("destroySuccess",((e,t)=>{log(4,`[pool] Pool resource [${t.id}] - Destroyed a worker successfully.`),t.page=null}));const t=[];for(let o=0;o{pool.release(e)})),log(3,"[pool] The pool is ready"+(t.length?` with ${t.length} initial resources waiting.`:"."))}catch(e){throw new ExportError("[pool] Could not configure and create the pool of workers.",500).setError(e)}}async function killPool(){if(log(3,"[pool] Killing pool with all workers and closing browser."),pool){for(const e of pool.used)pool.release(e.resource);pool.destroyed||(await pool.destroy(),log(4,"[pool] Destroyed the pool of resources.")),pool=null}await closeBrowser()}async function postWork(e){let t;try{if(log(4,"[pool] Work received, starting to process."),++poolStats.exportsAttempted,e.pool.benchmarking&&_getPoolInfo(),!pool)throw new ExportError("[pool] Work received, but pool has not been started.",500);const o=measureTime();try{log(4,"[pool] Acquiring a worker handle."),t=await pool.acquire().promise,e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Acquiring a worker handle took ${o()}ms.`)}catch(t){throw new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered when acquiring an available entry: ${o()}ms.`,400).setError(t)}if(log(4,"[pool] Acquired a worker handle."),!t.page)throw t.workCount=e.pool.workLimit+1,new ExportError("[pool] Resolved worker page is invalid: the pool setup is wonky.",400);log(4,`[pool] Pool resource [${t.id}] - Starting work on this pool entry.`);const r=measureTime(),i=await puppeteerExport(t.page,e.export,e.customLogic);if(i instanceof Error)throw"Rasterization timeout"===i.message&&(t.workCount=e.pool.workLimit+1,t.page=null),"TimeoutError"===i.name||"Rasterization timeout"===i.message?new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`).setError(i):new ExportError(`[pool] ${e.requestId?`Request [${e.requestId}] - `:""}Error encountered during export: ${r()}ms.`).setError(i);return e.server.benchmarking&&log(5,"[benchmark] "+(e.requestId?`Request [${e.requestId}] - `:""),`Exporting a chart sucessfully took ${r()}ms.`),pool.release(t),poolStats.timeSpent+=r(),poolStats.timeSpentAverage=poolStats.timeSpent/++poolStats.exportsPerformed,log(4,`[pool] Work completed in ${r()}ms.`),{result:i,options:e}}catch(e){throw++poolStats.exportsDropped,t&&pool.release(t),e}}function getPoolStats(){return poolStats}function getPoolInfoJSON(){return{min:pool.min,max:pool.max,used:pool.numUsed(),available:pool.numFree(),allCreated:pool.numUsed()+pool.numFree(),pendingAcquires:pool.numPendingAcquires(),pendingCreates:pool.numPendingCreates(),pendingValidations:pool.numPendingValidations(),pendingDestroys:pool.pendingDestroys.length,absoluteAll:pool.numUsed()+pool.numFree()+pool.numPendingAcquires()+pool.numPendingCreates()+pool.numPendingValidations()+pool.pendingDestroys.length}}function _getPoolInfo(){const{min:e,max:t,used:o,available:r,allCreated:i,pendingAcquires:n,pendingCreates:s,pendingValidations:a,pendingDestroys:l,absoluteAll:c}=getPoolInfoJSON();log(5,`[pool] The minimum number of resources allowed by pool: ${e}.`),log(5,`[pool] The maximum number of resources allowed by pool: ${t}.`),log(5,`[pool] The number of used resources: ${o}.`),log(5,`[pool] The number of free resources: ${r}.`),log(5,`[pool] The number of all created (used and free) resources: ${i}.`),log(5,`[pool] The number of resources waiting to be acquired: ${n}.`),log(5,`[pool] The number of resources waiting to be created: ${s}.`),log(5,`[pool] The number of resources waiting to be validated: ${a}.`),log(5,`[pool] The number of resources waiting to be destroyed: ${l}.`),log(5,`[pool] The number of all resources: ${c}.`)}function _factory(e){return{create:async()=>{const t={id:v4(),workCount:Math.round(Math.random()*(e.workLimit/2))};try{const e=getNewDateTime();return await newPage(t),log(3,`[pool] Pool resource [${t.id}] - Successfully created a worker, took ${getNewDateTime()-e}ms.`),t}catch(e){throw log(3,`[pool] Pool resource [${t.id}] - Error encountered when creating a new page.`),e}},validate:async t=>t.page?t.page.isClosed()?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page is closed or invalid).`),!1):t.page.mainFrame().detached?(log(3,`[pool] Pool resource [${t.id}] - Validation failed (page's frame is detached).`),!1):!(e.workLimit&&++t.workCount>e.workLimit)||(log(3,`[pool] Pool resource [${t.id}] - Validation failed (exceeded the ${e.workLimit} works per resource limit).`),!1):(log(3,`[pool] Pool resource [${t.id}] - Validation failed (no valid page is found).`),!1),destroy:async e=>{if(log(3,`[pool] Pool resource [${e.id}] - Destroying a worker.`),e.page&&!e.page.isClosed())try{e.page.removeAllListeners("pageerror"),e.page.removeAllListeners("console"),e.page.removeAllListeners("framedetached"),await e.page.close()}catch(t){throw log(3,`[pool] Pool resource [${e.id}] - Page could not be closed upon destroying.`),t}}}}function sanitize(e){const t=new JSDOM("").window;return DOMPurify(t).sanitize(e,{ADD_TAGS:["foreignObject"]})}let allowCodeExecution=!1;async function singleExport(e){if(!e||!e.export)throw new ExportError("[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.",400);await startExport({export:e.export,customLogic:e.customLogic},(async(e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r||`chart.${i}`,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}await killPool()}))}async function batchExport(e){if(!(e&&e.export&&e.export.batch))throw new ExportError("[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.",400);{const t=[];for(let o of e.export.batch.split(";")||[])o=o.split("="),2===o.length?t.push(startExport({export:{...e.export,infile:o[0],outfile:o[1]},customLogic:e.customLogic},((e,t)=>{if(e)throw e;const{b64:o,outfile:r,type:i}=t.options.export;try{o?writeFileSync(`${r.split(".").shift()||"chart"}.txt`,getBase64(t.result,i)):writeFileSync(r,"svg"!==i?Buffer.from(t.result,"base64"):t.result)}catch(e){throw new ExportError("[chart] Error while saving a chart.",500).setError(e)}}))):log(2,"[chart] No correct pair found for the batch export.");const o=await Promise.allSettled(t);await killPool(),o.forEach(((e,t)=>{e.reason&&logWithStack(1,e.reason,`[chart] Batch export number ${t+1} could not be correctly completed.`)}))}}async function startExport(e,t){try{if(!isObject(e))throw new ExportError("[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.",400);const o=updateOptions({export:e.export,customLogic:e.customLogic},!0),r=o.export;if(log(4,"[chart] Starting the exporting process."),null!==r.infile){let e;log(4,"[chart] Attempting to export from a file input.");try{e=readFileSync(getAbsolutePath(r.infile),"utf8")}catch(e){throw new ExportError("[chart] Error loading content from a file input.",400).setError(e)}if(r.infile.endsWith(".svg"))r.svg=validateOption("svg",e);else{if(!r.infile.endsWith(".json"))throw new ExportError("[chart] Incorrect value of the `infile` option.",400);r.instr=validateOption("instr",e)}}if(null!==r.svg){log(4,"[chart] Attempting to export from an SVG input."),++getPoolStats().exportsFromSvgAttempts;const e=await _exportFromSvg(sanitize(r.svg),o);return++getPoolStats().exportsFromSvg,t(null,e)}if(null!==r.instr||null!==r.options){log(4,"[chart] Attempting to export from options input."),++getPoolStats().exportsFromOptionsAttempts;const e=await _exportFromOptions(r.instr||r.options,o);return++getPoolStats().exportsFromOptions,t(null,e)}return t(new ExportError("[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.",400))}catch(e){return t(e)}}function getAllowCodeExecution(){return allowCodeExecution}function setAllowCodeExecution(e){allowCodeExecution=e}async function _exportFromSvg(e,t){if("string"==typeof e&&(e.indexOf("=0||e.indexOf("=0))return log(4,"[chart] Parsing input as SVG."),t.export.svg=e,t.export.options=null,t.export.instr=null,_prepareExport(t);throw new ExportError("[chart] Not a correct SVG input.",400)}async function _exportFromOptions(e,t){log(4,"[chart] Parsing input from options.");const o=isAllowedConfig(e,!0,t.customLogic.allowCodeExecution);if(null===o||"string"!=typeof o||!o.startsWith("{")||!o.endsWith("}"))throw new ExportError("[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.",403);return t.export.instr=o,t.export.options=null,t.export.svg=null,_prepareExport(t)}async function _prepareExport(e){const{export:t,customLogic:o}=e;return t.constr=_fixConstr(t.constr),t.type=_fixType(t.type,t.outfile),t.outfile=_fixOutfile(t.type,t.outfile),log(3,`[chart] The custom logic is ${o.allowCodeExecution?"allowed":"disallowed"}.`),_handleCustomLogic(o),_handleGlobalAndTheme(t,o),_handleSize(t),_checkDataSize({export:t,customLogic:o}),postWork(e)}function _fixConstr(e){try{const t=`${e.toLowerCase().replace("chart","")}Chart`;return"Chart"===t&&t.toLowerCase(),["chart","stockChart","mapChart","ganttChart"].includes(t)?t:"chart"}catch{return"chart"}}function _fixOutfile(e,t){return`${getAbsolutePath(t||"chart").split(".").shift()}.${e||"png"}`}function _fixType(e,t=null){const o={"image/png":"png","image/jpeg":"jpeg","application/pdf":"pdf","image/svg+xml":"svg"},r=Object.values(o);if(t){const o=t.split(".").pop();"jpg"===o?e="jpeg":r.includes(o)&&e!==o&&(e=o)}return o[e]||r.find((t=>t===e))||"png"}function _handleSize(e){const{chart:t,exporting:o}=isAllowedConfig(e.instr)||!1,{chart:r,exporting:i}=isAllowedConfig(e.globalOptions)||!1,{chart:n,exporting:s}=isAllowedConfig(e.themeOptions)||!1,a=e.height||o?.sourceHeight||t?.height||i?.sourceHeight||r?.height||s?.sourceHeight||n?.height||e.defaultHeight||400,l=e.width||o?.sourceWidth||t?.width||i?.sourceWidth||r?.width||s?.sourceWidth||n?.width||e.defaultWidth||600,c=roundNumber(Math.max(.1,Math.min(e.scale||o?.scale||i?.scale||s?.scale||e.defaultScale||1,5)),2);e.height=a,e.width=l,e.scale=c;for(let t of["height","width","scale"])"string"==typeof e[t]&&(e[t]=+e[t].replace(/px|%/gi,""))}function _handleCustomLogic(e){if(e.allowCodeExecution){try{e.resources=_handleResources(e.resources,e.allowFileResources,!0),e.resources=validateOption("resources",e.resources)}catch(t){log(2,"[chart] The `resources` cannot be loaded."),e.resources=null}try{e.customCode=_handleCustomCode(e.customCode,e.allowFileResources),e.customCode=validateOption("customCode",e.customCode)}catch(t){logWithStack(2,t,"[chart] The `customCode` cannot be loaded."),e.customCode=null}try{e.callback=_handleCustomCode(e.callback,e.allowFileResources,!0),e.callback=validateOption("callback",e.callback)}catch(t){logWithStack(2,t,"[chart] The `callback` cannot be loaded."),e.callback=null}[null,void 0].includes(e.customCode)&&log(3,"[chart] No value for the `customCode` option found."),[null,void 0].includes(e.callback)&&log(3,"[chart] No value for the `callback` option found."),[null,void 0].includes(e.resources)&&log(3,"[chart] No value for the `resources` option found.")}else if(e.callback||e.resources||e.customCode)throw e.callback=null,e.resources=null,e.customCode=null,new ExportError("[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.",403)}function _handleResources(e=null,t,o){let r=e;r||(e="resources.json");const i=["js","css","files"];let n=!1;t&&"string"==typeof e&&e.endsWith(".json")?r=isAllowedConfig(readFileSync(getAbsolutePath(e),"utf8"),!1,o):(r=isAllowedConfig(e,!1,o),r&&!t&&delete r.files);for(const e in r)i.includes(e)?n||(n=!0):delete r[e];return n?(r.files&&(r.files=r.files.map((e=>e.trim())),(!r.files||r.files.length<=0)&&delete r.files),r):null}function _handleCustomCode(e,t,o=!1){if(e&&"string"==typeof e)return(e=e.trim()).endsWith(".js")?t?_handleCustomCode(readFileSync(getAbsolutePath(e),"utf8"),t,o):null:!o&&(e.startsWith("function()")||e.startsWith("function ()")||e.startsWith("()=>")||e.startsWith("() =>"))?`(${e})()`:e.replace(/;$/,"")}function _handleGlobalAndTheme(e,t){const{allowFileResources:o,allowCodeExecution:r}=t;["globalOptions","themeOptions"].forEach((t=>{try{e[t]&&(o&&"string"==typeof e[t]&&e[t].endsWith(".json")?e[t]=isAllowedConfig(readFileSync(getAbsolutePath(e[t]),"utf8"),!0,r):e[t]=isAllowedConfig(e[t],!0,r),e[t]=validateOption(t,e[t]))}catch(o){logWithStack(2,o,`[chart] The \`${t}\` cannot be loaded.`),e[t]=null}})),[null,void 0].includes(e.globalOptions)&&log(3,"[chart] No value for the `globalOptions` option found."),[null,void 0].includes(e.themeOptions)&&log(3,"[chart] No value for the `themeOptions` option found.")}function _checkDataSize(e){const t=Buffer.byteLength(JSON.stringify(e),"utf-8");if(log(3,`[chart] The current total size of the data for the export process is around ${(t/1048576).toFixed(2)}MB.`),t>=104857600)throw new ExportError("[chart] The data for the export process exceeds 100MB limit.")}const timerIds=[];function addTimer(e){timerIds.push(e)}function clearAllTimers(){log(4,"[timer] Clearing all registered intervals and timeouts.");for(const e of timerIds)clearInterval(e),clearTimeout(e)}function logErrorMiddleware(e,t,o,r){return logWithStack(1,e),"development"!==getOptions().other.nodeEnv&&delete e.stack,r(e)}function returnErrorMiddleware(e,t,o,r){const{message:i,stack:n}=e,s=e.statusCode||400;o.status(s).json({statusCode:s,message:i,stack:n})}function errorMiddleware(e){e.use(logErrorMiddleware),e.use(returnErrorMiddleware)}function rateLimitingMiddleware(e,t){try{if(e&&t.enable){const o="Too many requests, you have been rate limited. Please try again later.",r={window:t.window||1,maxRequests:t.maxRequests||30,delay:t.delay||0,trustProxy:t.trustProxy||!1,skipKey:t.skipKey||null,skipToken:t.skipToken||null};r.trustProxy&&e.enable("trust proxy");const i=rateLimit({windowMs:60*r.window*1e3,limit:r.maxRequests,delayMs:r.delay,handler:(e,t)=>{t.format({json:()=>{t.status(429).send({message:o})},default:()=>{t.status(429).send(o)}})},skip:e=>null!==r.skipKey&&null!==r.skipToken&&e.query.key===r.skipKey&&e.query.access_token===r.skipToken&&(log(4,"[rate limiting] Skipping rate limiter."),!0)});e.use(i),log(3,`[rate limiting] Enabled rate limiting with ${r.maxRequests} requests per ${r.window} minute for each IP, trusting proxy: ${r.trustProxy}.`)}}catch(e){throw new ExportError("[rate limiting] Could not configure and set the rate limiting options.",500).setError(e)}}function contentTypeMiddleware(e,t,o){try{const t=e.headers["content-type"]||"";if(!t.includes("application/json")&&!t.includes("application/x-www-form-urlencoded")&&!t.includes("multipart/form-data"))throw new ExportError("[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.",415);return o()}catch(e){return o(e)}}function requestBodyMiddleware(e,t,o){try{const t=e.body,r=v4();if(!t||isObjectEmpty(t))throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is empty.`),new ExportError(`[validation] Request [${r}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,400);const i=getAllowCodeExecution(),n=isAllowedConfig(t.instr||t.options||t.infile||t.data,!0,i);if(null===n&&!t.svg)throw log(2,`[validation] Request [${r}] - The request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(t)}.`),new ExportError(`[validation] Request [${r}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,400);if(t.svg&&isPrivateRangeUrlFound(t.svg))throw new ExportError(`[validation] Request [${r}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,400);return e.validatedOptions={requestId:r,export:{instr:n,svg:t.svg,outfile:t.outfile||`${e.params.filename||"chart"}.${t.type||"png"}`,type:t.type,constr:t.constr,b64:t.b64,noDownload:t.noDownload,height:t.height,width:t.width,scale:t.scale,globalOptions:isAllowedConfig(t.globalOptions,!0,i),themeOptions:isAllowedConfig(t.themeOptions,!0,i)},customLogic:{allowCodeExecution:i,allowFileResources:!1,customCode:t.customCode,callback:t.callback,resources:isAllowedConfig(t.resources,!0,i)}},o()}catch(e){return o(e)}}function validationMiddleware(e){e.post(["/","/:filename"],contentTypeMiddleware),e.post(["/","/:filename"],requestBodyMiddleware)}const reversedMime={png:"image/png",jpeg:"image/jpeg",gif:"image/gif",pdf:"application/pdf",svg:"image/svg+xml"};async function requestExport(e,t,o){try{const o=measureTime();let r=!1;e.socket.on("close",(e=>{e&&(r=!0)}));const i=e.validatedOptions,n=i.requestId;log(4,`[export] Request [${n}] - Got an incoming HTTP request.`),await startExport(i,((i,s)=>{if(e.socket.removeAllListeners("close"),r)log(3,`[export] Request [${n}] - The client closed the connection before the chart finished processing.`);else{if(i)throw i;if(!s||!s.result)throw log(2,`[export] Request [${n}] - Request from ${e.headers["x-forwarded-for"]||e.connection.remoteAddress} was incorrect. Received result is ${s.result}.`),new ExportError(`[export] Request [${n}] - Unexpected return of the export result from the chart generation. Please check your request data.`,400);if(s.result){log(3,`[export] Request [${n}] - The whole exporting process took ${o()}ms.`);const{type:e,b64:r,noDownload:i,outfile:a}=s.options.export;return r?t.send(getBase64(s.result,e)):(t.header("Content-Type",reversedMime[e]||"image/png"),i||t.attachment(a),"svg"===e?t.send(s.result):t.send(Buffer.from(s.result,"base64")))}}}))}catch(e){return o(e)}}function exportRoutes(e){e.post("/",requestExport),e.post("/:filename",requestExport)}const serverStartTime=new Date,packageFile=JSON.parse(readFileSync(join(__dirname,"package.json"),"utf8")),successRates=[],recordInterval=6e4,windowSize=30;function _calculateMovingAverage(){return successRates.reduce(((e,t)=>e+t),0)/successRates.length}function _startSuccessRate(){return setInterval((()=>{const e=getPoolStats(),t=0===e.exportsAttempted?1:e.exportsPerformed/e.exportsAttempted*100;successRates.push(t),successRates.length>windowSize&&successRates.shift()}),recordInterval)}function healthRoutes(e){addTimer(_startSuccessRate()),e.get("/health",((e,t,o)=>{try{log(4,"[health] Returning server health.");const e=getPoolStats(),o=successRates.length,r=_calculateMovingAverage();t.send({status:"OK",bootTime:serverStartTime,uptime:`${Math.floor((getNewDateTime()-serverStartTime.getTime())/1e3/60)} minutes`,serverVersion:packageFile.version,highchartsVersion:getHcVersion(),averageExportTime:e.timeSpentAverage,attemptedExports:e.exportsAttempted,performedExports:e.exportsPerformed,failedExports:e.exportsDropped,sucessRatio:e.exportsPerformed/e.exportsAttempted*100,pool:getPoolInfoJSON(),period:o,movingAverage:r,message:isNaN(r)||!successRates.length?"Too early to report. No exports made yet. Please check back soon.":`Last ${o} minutes had a success rate of ${r.toFixed(2)}%.`,svgExports:e.exportsFromSvg,jsonExports:e.exportsFromOptions,svgExportsAttempts:e.exportsFromSvgAttempts,jsonExportsAttempts:e.exportsFromOptionsAttempts})}catch(e){return o(e)}}))}function uiRoutes(e){getOptions().ui.enable&&e.get(getOptions().ui.route||"/",((e,t,o)=>{try{log(4,"[ui] Returning UI for the export."),t.sendFile(join(__dirname,"public","index.html"),{acceptRanges:!1})}catch(e){return o(e)}}))}function versionChangeRoutes(e){e.post("/version_change/:newVersion",(async(e,t,o)=>{try{log(4,"[version] Changing Highcharts version.");const o=envs.HIGHCHARTS_ADMIN_TOKEN;if(!o||!o.length)throw new ExportError("[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.",401);const r=e.get("hc-auth");if(!r||r!==o)throw new ExportError("[version] Invalid or missing token: Set the token in the hc-auth header.",401);const i=e.params.newVersion;if(!i)throw new ExportError("[version] No new version supplied.",400);try{await updateHcVersion(i)}catch(e){throw new ExportError(`[version] Version change: ${e.message}`,400).setError(e)}t.status(200).send({statusCode:200,highchartsVersion:getHcVersion(),message:`Successfully updated Highcharts to version: ${i}.`})}catch(e){return o(e)}}))}const activeServers=new Map,app=express();async function startServer(e={}){try{const t=updateOptions({server:e});if(!(e=t.server).enable||!app)throw new ExportError("[server] Server cannot be started (not enabled or no correct Express app found).",500);const o=1024*e.uploadLimit*1024,r=multer.memoryStorage(),i=multer({storage:r,limits:{fieldSize:o}});if(app.disable("x-powered-by"),app.use(cors({methods:["POST","GET","OPTIONS"]})),app.use(((e,t,o)=>{t.set("Accept-Ranges","none"),o()})),app.use(express.json({limit:o})),app.use(express.urlencoded({extended:!0,limit:o})),app.use(i.none()),app.use(express.static(join(__dirname,"public"))),!e.ssl.force){const t=http.createServer(app);_attachServerErrorHandlers(t),t.listen(e.port,e.host,(()=>{activeServers.set(e.port,t),log(3,`[server] Started HTTP server on ${e.host}:${e.port}.`)}))}if(e.ssl.enable){let t,o;try{t=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.key"),"utf8"),o=readFileSync(join(getAbsolutePath(e.ssl.certPath),"server.crt"),"utf8")}catch(t){log(2,`[server] Unable to load key/certificate from the '${e.ssl.certPath}' path. Could not run secured layer server.`)}if(t&&o){const r=https.createServer({key:t,cert:o},app);_attachServerErrorHandlers(r),r.listen(e.ssl.port,e.host,(()=>{activeServers.set(e.ssl.port,r),log(3,`[server] Started HTTPS server on ${e.host}:${e.ssl.port}.`)}))}}rateLimitingMiddleware(app,e.rateLimiting),validationMiddleware(app),exportRoutes(app),healthRoutes(app),uiRoutes(app),versionChangeRoutes(app),errorMiddleware(app)}catch(e){throw new ExportError("[server] Could not configure and start the server.",500).setError(e)}}function closeServers(){if(activeServers.size>0){log(4,"[server] Closing all servers.");for(const[e,t]of activeServers)t.close((()=>{activeServers.delete(e),log(4,`[server] Closed server on port: ${e}.`)}))}}function getServers(){return activeServers}function getExpress(){return express}function getApp(){return app}function enableRateLimiting(e){const t=updateOptions({server:{rateLimiting:e}});rateLimitingMiddleware(app,t.server.rateLimitingOptions)}function use(e,...t){app.use(e,...t)}function get(e,...t){app.get(e,...t)}function post(e,...t){app.post(e,...t)}function _attachServerErrorHandlers(e){e.on("clientError",((e,t)=>{logWithStack(1,e,`[server] Client error: ${e.message}, destroying socket.`),t.destroy()})),e.on("error",(e=>{logWithStack(1,e,`[server] Server error: ${e.message}`)})),e.on("connection",(e=>{e.on("error",(e=>{logWithStack(1,e,`[server] Socket error: ${e.message}`)}))}))}var server={startServer:startServer,closeServers:closeServers,getServers:getServers,getExpress:getExpress,getApp:getApp,enableRateLimiting:enableRateLimiting,use:use,get:get,post:post};async function shutdownCleanUp(e=0){await Promise.allSettled([clearAllTimers(),closeServers(),killPool()]),process.exit(e)}async function initExport(e={}){const t=updateOptions(e);setAllowCodeExecution(t.customLogic.allowCodeExecution),initLogging(t.logging),t.other.listenToProcessExits&&_attachProcessExitListeners(),await checkCache(t.highcharts,t.server.proxy),await initPool(t.pool,t.puppeteer.args)}function _attachProcessExitListeners(){log(3,"[process] Attaching exit listeners to the process."),process.on("exit",(e=>{log(4,`[process] Process exited with code: ${e}.`)})),process.on("SIGINT",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGTERM",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("SIGHUP",(async(e,t)=>{log(4,`[process] The ${e} event with code: ${t}.`),await shutdownCleanUp()})),process.on("uncaughtException",(async(e,t)=>{logWithStack(1,e,`[process] The ${t} error.`),await shutdownCleanUp(1)}))}var index={...server,getOptions:getOptions,updateOptions:updateOptions,mapToNewOptions:mapToNewOptions,validateOption:validateOption,validateOptions:validateOptions,initExport:initExport,singleExport:singleExport,batchExport:batchExport,startExport:startExport,killPool:killPool,shutdownCleanUp:shutdownCleanUp,log:log,logWithStack:logWithStack,logZodIssues:logZodIssues,setLogLevel:function(e){setLogLevel(updateOptions({logging:{level:e}}).logging.level)},enableConsoleLogging:function(e){enableConsoleLogging(updateOptions({logging:{toConsole:e}}).logging.toConsole)},enableFileLogging:function(e,t,o){const r=updateOptions({logging:{dest:e,file:t,toFile:o}});enableFileLogging(r.logging.dest,r.logging.file,r.logging.toFile)}};export{index as default,initExport}; //# sourceMappingURL=index.esm.js.map diff --git a/dist/index.esm.js.map b/dist/index.esm.js.map index 04e03491..9e201678 100644 --- a/dist/index.esm.js.map +++ b/dist/index.esm.js.map @@ -1 +1 @@ -{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function getAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an object, `false`\r\n * otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an empty object, `false`\r\n * otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} Returns `true` if a private IP range URL is found, `false`\r\n * otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || 'log';\r\n logging.file = file || 'highcharts-export-server.log';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * It provides a default configuration object with predefined default values,\r\n * descriptions, and characteristics for each option used in the Export Server.\r\n */\r\n\r\n/**\r\n * The default configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option.\r\n * - Data types for validation.\r\n * - Names of corresponding environment variables.\r\n * - Descriptions of each property.\r\n * - Information used for prompts in interactive configuration.\r\n * - [Optional] Corresponding CLI argument names for CLI usage.\r\n * - [Optional] Legacy names from the previous PhantomJS-based server.\r\n */\r\nconst defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\nexport default defaultConfig;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n // Set the `message` and `stackMessage` with provided message\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n // Set the `statusCode` if provided\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n // Save the provided error\r\n this.error = error;\r\n\r\n // Set the error's name if present\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n // Set the error's status code if present\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n // Set the error's stack and stack's message if present\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n // Return updated `ExportError` instance\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module manages configuration for the Highcharts Export Server\r\n * by loading and merging options from multiple sources, such as the default\r\n * settings, environment variables, user-provided options, and command-line\r\n * arguments. Ensures the global options are up-to-date with the highest\r\n * priority values. Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n// Properties nesting level of all options\r\nconst nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nconst absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or an original global options\r\n * object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `true`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n // Return a copy or an original global options object\r\n return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object or a copy of the global options\r\n * object, based on the `getCopy` flag. The `newOptions` object can be\r\n * strictly validated depending on the `strictCheck` flag.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false, strictCheck = true) {\r\n // Merge new options to the global options or its copy and return the result\r\n return _mergeOptions(\r\n // First, get the options\r\n getOptions(getCopy),\r\n // Next, validate the new options\r\n validateOptions(newOptions, strictCheck)\r\n );\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object with values provided through\r\n * the CLI, keeping the principle of options load priority. The function accepts\r\n * a `cliArgs` array containing arguments from the CLI, which will be validated\r\n * and applied if provided.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from the command line interface (CLI).\r\n * 2. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Get options from the custom JSON loaded via the `--loadConfig`\r\n const configOptions = _loadConfigFile(cliArgs);\r\n\r\n // Update global options with validated values from the `configOptions`\r\n updateOptions(configOptions);\r\n } catch (error) {\r\n log(2, '[validation] No options added from the `--loadConfig` option.');\r\n }\r\n\r\n try {\r\n // Get options from the CLI\r\n const cliOptions = _pairArgumentValue(cliArgs);\r\n\r\n // Update global options with validated values from the `cliOptions`\r\n updateOptions(cliOptions, false, false);\r\n } catch (error) {\r\n log(2, '[validation] No options added from the CLI arguments.');\r\n }\r\n }\r\n\r\n // Return reference to the global options\r\n return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS-based) to a new format\r\n * (Puppeteer-based). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping provided\r\n * in the `nestedProps` object. The new format is used for Puppeteer, while\r\n * the old format was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in the `nestedProps` object or an empty object\r\n * if the provided `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty object.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If `true`, functions are preserved. Otherwise, when\r\n * a function is found, `null` is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is `true`, and `null`\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return `null` if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return `null` if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from environment variables (specified in the `.env` file).\r\n * 2. Values from the `./lib/schemas/config.js` file (defaults).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n // Init the object for options\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // Set the correct value based on the established priority order\r\n if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n // The environment variables value\r\n options[name] = envs[item.envLink];\r\n } else {\r\n // The value from the config file\r\n options[name] = item.value;\r\n }\r\n } else {\r\n // Create a category of options in the `options` object\r\n options[name] = _initOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Recursively merges two sets of configuration options, taking into account\r\n * properties specified in the `absoluteProps` array that require absolute\r\n * merging. The `originalOptions` object will be extended with options from\r\n * the `newOptions` object.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - The original configuration options object\r\n * to be extended.\r\n * @param {Object} newOptions - The new configuration options object to merge.\r\n *\r\n * @returns {Object} The extended `originalOptions` object.\r\n */\r\nfunction _mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? _mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON string with the option\r\n * to preserve functions. In order for a function to be preserved, it needs\r\n * to follow the format `function (...) {...}`. Such a function can also\r\n * be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to `true`, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to `true`, functions are saved\r\n * as strings. The `allowFunctions` must be set to `true` as well for this\r\n * to take an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nfunction _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If `value` is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If the `allowFunctions` is set to `true`, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n // Get the allow flags for the custom logic check\r\n const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n // Check if the `--loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `--loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `--loadConfig` is present and has a correct value\r\n if (configFileName && allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings in the `nestedProps` object.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * should be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n updateOptions,\r\n setCliOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Sends a GET request to the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function get\r\n *\r\n * @param {string} url - The URL to get data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function get(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n // Decide on the protocol\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n\r\n // Get the full result and resolve the request\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with `requestOptions`\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n // Decide on the protocol\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n // Get the full result and resolve the request\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (`http` or `https`).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { get } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkCache(highchartsOptions, serverProxyOptions) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n\r\n // The initial cache update\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n // Check the Highcharts version\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n // Check the number of modules\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = _extractHcVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions.version, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHcVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHcVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the scripts of a new version.\r\n *\r\n * @async\r\n * @function updateHcVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHcVersion(newVersion) {\r\n // Update to the new version\r\n const options = updateOptions({\r\n highcharts: {\r\n version: newVersion\r\n }\r\n });\r\n\r\n // Check if cache needs to be updated\r\n await checkCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {number} version - The currently used Highcharts version.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which modules\r\n * have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(version, fetchedModules = {}) {\r\n // Update cache object with the current modules\r\n cache.activeManifest = {\r\n version,\r\n modules: fetchedModules\r\n };\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(cache.activeManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts content and information,\r\n * and used Highcharts version.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n try {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n // Prepare options for a request\r\n const requestOptions = _configureRequest(serverProxyOptions);\r\n\r\n // An object to record which scripts are fetched\r\n const fetchedModules = {};\r\n\r\n // Join all fetched scripts and save in the manifest's sources\r\n cache.sources = (\r\n await Promise.all([\r\n // Highcharts core scripts fetch\r\n ...highchartsOptions.coreScripts.map((cs) =>\r\n _fetchScript(\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${cs}` : `${cdnUrl}/${cs}`,\r\n requestOptions,\r\n fetchedModules,\r\n true\r\n )\r\n ),\r\n // Highcharts module scripts fetch\r\n ...highchartsOptions.moduleScripts.map((ms) =>\r\n _fetchScript(\r\n ms === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${ms}`\r\n : `${cdnUrl}/maps/modules/${ms}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${ms}`\r\n : `${cdnUrl}/modules/${ms}`,\r\n requestOptions,\r\n fetchedModules\r\n )\r\n ),\r\n // Highcharts indicator scripts fetch\r\n ...highchartsOptions.indicatorScripts.map((is) =>\r\n _fetchScript(\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${is}`\r\n : `${cdnUrl}/stock/indicators/${is}`,\r\n requestOptions,\r\n fetchedModules\r\n )\r\n ),\r\n // Custom scripts fetch\r\n ...highchartsOptions.customScripts.map((cs) =>\r\n _fetchScript(`${cs}`, requestOptions)\r\n )\r\n ])\r\n ).join(';\\n');\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = _extractHcVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n\r\n // Return the fetched modules\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional requests options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await get(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = _extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Configures a proxy agent for outgoing HTTP requests based on the provided\r\n * `server.proxy` options. If a valid `host` and `port` are specified, it tries\r\n * to create an `HttpsProxyAgent`. If the creation fails, an `ExportError`\r\n * is thrown. If no proxy is configured, an empty object is returned.\r\n *\r\n * @function _configureRequest\r\n *\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n *\r\n * @returns {Object} The request options, including the proxy agent if created,\r\n * or an empty object if no proxy configuration is provided.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the proxy agent creation\r\n * fails.\r\n */\r\nfunction _configureRequest(serverProxyOptions) {\r\n // Get the `host` and `port` of the proxy\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a proxy agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n // Create the agent\r\n const proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n\r\n // Add the agent to the request's options\r\n return {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n };\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // Return an empty object when no proxy agent is created\r\n return {};\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function _extractHcVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nfunction _extractHcVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the `scriptPath` property.\r\n *\r\n * @function _extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nfunction _extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\nexport default {\r\n checkCache,\r\n getHcVersion,\r\n updateHcVersion,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get all images from within the chart\r\n const images = Array.from(\r\n document.querySelectorAll('.highcharts-container image')\r\n );\r\n\r\n // Wait for all images for 2 seconds\r\n await Promise.race([\r\n Promise.all(\r\n images.map((image) =>\r\n image.complete && image.naturalHeight !== 0\r\n ? Promise.resolve()\r\n : new Promise((resolve) =>\r\n image.addEventListener('load', resolve, { once: true })\r\n )\r\n )\r\n ),\r\n // Proceed further even if images did not load\r\n new Promise((resolve) => setTimeout(resolve, 2000))\r\n ]);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom JS and CSS resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that the browser and pages are correctly managed and can handle failures\r\n * during operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst pageTemplate = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array} puppeteerArgs - Additional arguments for Puppeteer\r\n * browser's launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n const openBrowser = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to launch and get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await openBrowser();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n // Try to open a browser\r\n await openBrowser();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // No correct browser\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If `true`, navigates to `about:blank` and resets content\r\n * and scripts. If `false`, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to `true` when page\r\n * is correctly cleared and `false` when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use the content of the `resources`\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = file.startsWith('http') ? false : true;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n // The actual injection of collected scripts\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n const cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: getAbsolutePath(cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n // The actual injection of collected CSS\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(pageTemplate, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = await _getChartSize(page, isSVG, exportOptions.scale);\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Retrieves the real chart dimensions from a Puppeteer page. The function\r\n * behaves differently based on whether the export type is SVG or another\r\n * format.\r\n *\r\n * @async\r\n * @function _getChartSize\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {boolean} isSVG - Determines whether the chart being processed\r\n * is an SVG or another format.\r\n * @param {number} scale - The scale factor to be applied to the chart\r\n * dimensions.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * the actual height and width of the chart after scaling.\r\n */\r\nasync function _getChartSize(page, isSVG, scale) {\r\n // Trigger appropriate function based on the `isSvg` flag to get chart size\r\n return isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n _getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const exportResult = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (exportResult instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // Only `page.screenshot` will throw this, timeouts for PDF's are\r\n // handled by the `page.pdf` function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (exportResult.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n exportResult.name === 'TimeoutError' ||\r\n exportResult.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(exportResult);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(exportResult);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Update statistics\r\n poolStats.timeSpent += exportCounter();\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportCounter()}ms.`);\r\n\r\n // Otherwise return an object with the result and options\r\n return {\r\n result: exportResult,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n // Try to release the worker, if it exists\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or `null`\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function _getPoolInfo\r\n */\r\nfunction _getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`, `destroy`\r\n * functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a `TargetCloseError`, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input, allowing for the `foreignObject` elements\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions that prepare for the exporting\r\n * charts into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { isAllowedConfig, updateOptions, validateOption } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport { getAbsolutePath, getBase64, isObject, roundNumber } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n try {\r\n // Check if provided options are in an object\r\n if (!isObject(imageOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = updateOptions(\r\n {\r\n export: imageOptions.export,\r\n customLogic: imageOptions.customLogic\r\n },\r\n true\r\n );\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.options = null;\r\n options.export.instr = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.options = null;\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n // Get the `export` and `customLogic` options\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = _fixConstr(exportOptions.constr);\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = _fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = _fixOutfile(\r\n exportOptions.type,\r\n exportOptions.outfile\r\n );\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the `customCode`, `callback`, and `resources` options\r\n _handleCustomLogic(customLogicOptions);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(exportOptions, customLogicOptions);\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n _handleSize(exportOptions);\r\n\r\n // Check if the image options object does not exceed the size limit\r\n _checkDataSize({ export: exportOptions, customLogic: customLogicOptions });\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Handles adjusting the constructor name by transforming and normalizing\r\n * it based on common chart types.\r\n *\r\n * @function _fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be adjusted.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Handles fixing the outfile based on provided type.\r\n *\r\n * @function _fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile, or 'chart.png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type || 'png'}`;\r\n}\r\n\r\n/**\r\n * Handles fixing the export type based on MIME types and file extensions.\r\n *\r\n * @function _fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type, or 'png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Handle calculating the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _handleSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n */\r\nfunction _handleSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Find the `scale` value:\r\n // - Cannot be lower than 0.1\r\n // - Cannot be higher than 5.0\r\n // - Must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Update `height`, `width`, and `scale` information in the `export` options\r\n exportOptions.height = height;\r\n exportOptions.width = width;\r\n exportOptions.scale = scale;\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let param of ['height', 'width', 'scale']) {\r\n if (typeof exportOptions[param] === 'string') {\r\n exportOptions[param] = +exportOptions[param].replace(/px|%/gi, '');\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions) {\r\n // In case of allowing code execution\r\n if (customLogicOptions.allowCodeExecution) {\r\n // Process the `resources` option\r\n try {\r\n // Try to handle resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n } catch (error) {\r\n log(2, '[chart] The `resources` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.resources = null;\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = _handleCustomCode(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = _handleCustomCode(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n let handledResources = resources;\r\n\r\n // If no resources found, try to load the default resources\r\n if (!handledResources) {\r\n resources = 'resources.json';\r\n }\r\n\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n // A flag that decides based to return resources or `null`\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (\r\n allowFileResources &&\r\n typeof resources === 'string' &&\r\n resources.endsWith('.json')\r\n ) {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Validate option\r\n handledResources = validateOption('resources', handledResources);\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles custom code to execute it safely.\r\n *\r\n * @function _handleCustomCode\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nfunction _handleCustomCode(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? _handleCustomCode(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is `true`), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to `null`. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to `null`.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n */\r\nfunction _handleGlobalAndTheme(exportOptions, customLogicOptions) {\r\n // Get the `allowFileResources` and `allowCodeExecution` flags\r\n const { allowFileResources, allowCodeExecution } = customLogicOptions;\r\n\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\n/**\r\n * Validates the size of the data for the export process against a fixed limit\r\n * of 100MB.\r\n *\r\n * @function _checkDataSize\r\n *\r\n * @param {Object} imageOptions - The data object, which includes options from\r\n * the `export` and `customLogic` sections and will be sent to a Puppeteer page.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the size of the data for\r\n * the export process object exceeds the 100MB limit.\r\n */\r\nfunction _checkDataSize(imageOptions) {\r\n // Set the fixed data limit (100MB) for the dev-tools protocol\r\n const dataLimit = 100 * 1024 * 1024;\r\n\r\n // Get the size of the data\r\n const totalSize = Buffer.byteLength(JSON.stringify(imageOptions), 'utf-8');\r\n\r\n // Log the size in MB\r\n log(\r\n 3,\r\n `[chart] The current total size of the data for the export process is around ${(\r\n totalSize /\r\n (1024 * 1024)\r\n ).toFixed(2)}MB.`\r\n );\r\n\r\n // Check the size of data before passing to a page\r\n if (totalSize >= dataLimit) {\r\n throw new ExportError(\r\n `[chart] The data for the export process exceeds 100MB limit.`\r\n );\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed to avoid potential\r\n * memory leaks, unintended behavior or a process from being stopped.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled and the app exists\r\n if (app && rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get and pre-validate the options and store them in the request\r\n request.validatedOptions = {\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n };\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const options = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = options.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(options, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHcVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n // Add the UI endpoint only if required\r\n if (getOptions().ui.enable) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHcVersion, updateHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the new version from the params\r\n const newVersion = request.params.newVersion;\r\n\r\n // Update version\r\n if (newVersion) {\r\n try {\r\n await updateHcVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHcVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middlewares setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} serverOptions - The configuration object containing `server`\r\n * options. This object may include a partial or complete set of the `server`\r\n * options. If the options are partial, missing values will default\r\n * to the current global configuration.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: serverOptions\r\n });\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n });\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This core module initializes and manages the Highcharts Export\r\n * Server. The main `initExport` function handles logging, script caching,\r\n * resource pooling, browser startup, and ensures graceful process cleanup\r\n * on exit. Additionally, it provides API functions for using it as a Node.js\r\n * module, offering functionalities for processing options, configuring\r\n * and performing exports, and setting up server.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkCache } from './cache.js';\r\nimport {\r\n batchExport,\r\n singleExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} initOptions - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration.\r\n */\r\nexport async function initExport(initOptions) {\r\n // Init, validate and update the options object\r\n const options = updateOptions(initOptions);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check the current status of cache\r\n await checkCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM',\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code: ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n level\r\n }\r\n });\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n });\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n });\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","getAbsolutePath","path","isAbsolute","normalize","resolve","getBase64","input","type","Buffer","from","toString","getNewDate","Date","split","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","shift","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","outfile","hint","choices","constr","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","allowFileResources","customCode","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","dotenv","config","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","includes","nullable","string","refine","params","errorMessage","values","stringArray","filterCallback","arraySchema","array","stringSchema","startsWith","slice","endsWith","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","forEach","index","substring","ExportError","Error","constructor","statusCode","super","setError","name","_initOptions","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","validateOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","propChain","entry","async","get","requestOptions","Promise","reject","_getProtocolModule","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","readFileSync","modules","moduleMap","m","numberOfModules","moduleName","_extractHcVersion","_saveConfigToManifest","getHcVersion","updateHcVersion","newVersion","writeFileSync","_configureRequest","all","cs","_fetchScript","ms","is","script","shouldThrowError","_extractModuleName","agent","HttpsProxyAgent","cacheSources","replace","scriptPath","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","images","document","querySelectorAll","race","image","complete","naturalHeight","addEventListener","once","setTimeout","defaultOptions","pageTemplate","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","openBrowser","launch","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","_getChartSize","x","y","_getClipRegion","viewportHeight","abs","ceil","chartHeight","viewportWidth","chartWidth","result","setViewport","deviceScaleFactor","parseFloat","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","svgElement","querySelector","baseVal","style","zoom","margin","outerHTML","clip","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","i","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","_getPoolInfo","acquireCounter","exportCounter","exportResult","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_fixConstr","_fixType","_fixOutfile","_handleCustomLogic","_handleGlobalAndTheme","_handleSize","_checkDataSize","fixedConstr","toLowerCase","mimeTypes","formats","outType","pop","find","t","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","_handleCustomCode","handledResources","allowedProps","correctResources","propName","isCallback","optionsName","totalSize","byteLength","toFixed","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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SAGVwF,WAAY,CACV9D,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGVyF,UAAW,CACT/D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbnF,KAAM,SAGV0F,YAAa,CACXhE,MAAO,CAAC,aAAc,kBAAmB,iBACzCqD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBC,cAAe,CACblE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBE,iBAAkB,CAChBnE,MAAO,CAAC,kBACRqD,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBG,cAAe,CACbpE,MAAO,CACL,wEACA,kGAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbnF,KAAM,OACNoF,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACNtE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbnF,KAAM,SAGViG,MAAO,CACLvE,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbnF,KAAM,SAGVkG,QAAS,CACPxE,MAAO,KACPqD,MAAO,CAAC,SAAU,S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"} \ No newline at end of file +{"version":3,"file":"index.esm.js","sources":["../lib/utils.js","../lib/logger.js","../lib/schemas/config.js","../lib/validation.js","../lib/errors/ExportError.js","../lib/config.js","../lib/fetch.js","../lib/cache.js","../lib/highcharts.js","../lib/browser.js","../templates/svgExport/css.js","../templates/svgExport/svgExport.js","../lib/export.js","../lib/pool.js","../lib/sanitize.js","../lib/chart.js","../lib/timer.js","../lib/server/middlewares/error.js","../lib/server/middlewares/rateLimiting.js","../lib/server/middlewares/validation.js","../lib/server/routes/export.js","../lib/server/routes/health.js","../lib/server/routes/ui.js","../lib/server/routes/versionChange.js","../lib/server/server.js","../lib/resourceRelease.js","../lib/index.js"],"sourcesContent":["/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The Highcharts Export Server utility module provides\r\n * a comprehensive set of helper functions and constants designed to streamline\r\n * and enhance various operations required for Highcharts export tasks.\r\n */\r\n\r\nimport { isAbsolute, normalize, resolve } from 'path';\r\nimport { fileURLToPath } from 'url';\r\n\r\nconst MAX_BACKOFF_ATTEMPTS = 6;\r\n\r\n// The directory path\r\nexport const __dirname = fileURLToPath(new URL('../.', import.meta.url));\r\n\r\n/**\r\n * Clears and standardizes text by replacing multiple consecutive whitespace\r\n * characters with a single space and trimming any leading or trailing\r\n * whitespace.\r\n *\r\n * @function clearText\r\n *\r\n * @param {string} text - The input text to be cleared.\r\n * @param {RegExp} [rule=/\\s\\s+/g] - The regular expression rule to match\r\n * multiple consecutive whitespace characters. The default value\r\n * is the '/\\s\\s+/g' RegExp.\r\n * @param {string} [replacer=' '] - The string used to replace multiple\r\n * consecutive whitespace characters. The default value is the ' ' string.\r\n *\r\n * @returns {string} The cleared and standardized text.\r\n */\r\nexport function clearText(text, rule = /\\s\\s+/g, replacer = ' ') {\r\n return text.replaceAll(rule, replacer).trim();\r\n}\r\n\r\n/**\r\n * Creates a deep copy of the given object or array.\r\n *\r\n * @function deepCopy\r\n *\r\n * @param {(Object|Array)} objArr - The object or array to be deeply copied.\r\n *\r\n * @returns {(Object|Array)} The deep copy of the provided object or array.\r\n */\r\nexport function deepCopy(objArr) {\r\n // If the `objArr` is null or not of the `object` type, return it\r\n if (objArr === null || typeof objArr !== 'object') {\r\n return objArr;\r\n }\r\n\r\n // Prepare either a new array or a new object\r\n const objArrCopy = Array.isArray(objArr) ? [] : {};\r\n\r\n // Recursively copy each property\r\n for (const key in objArr) {\r\n if (Object.prototype.hasOwnProperty.call(objArr, key)) {\r\n objArrCopy[key] = deepCopy(objArr[key]);\r\n }\r\n }\r\n\r\n // Return the copied object\r\n return objArrCopy;\r\n}\r\n\r\n/**\r\n * Implements an exponential backoff strategy for retrying a function until\r\n * a certain number of attempts are reached.\r\n *\r\n * @async\r\n * @function expBackoff\r\n *\r\n * @param {Function} fn - The function to be retried.\r\n * @param {number} [attempt=0] - The current attempt number. The default value\r\n * is `0`.\r\n * @param {...unknown} args - Arguments to be passed to the function.\r\n *\r\n * @returns {Promise} A Promise that resolves to the result\r\n * of the function if successful.\r\n *\r\n * @throws {Error} Throws an `Error` if the maximum number of attempts\r\n * is reached.\r\n */\r\nexport async function expBackoff(fn, attempt = 0, ...args) {\r\n try {\r\n // Try to call the function\r\n return await fn(...args);\r\n } catch (error) {\r\n // Calculate delay in ms\r\n const delayInMs = 2 ** attempt * 1000;\r\n\r\n // If the attempt exceeds the maximum attempts of repeat, throw an error\r\n if (++attempt >= MAX_BACKOFF_ATTEMPTS) {\r\n throw error;\r\n }\r\n\r\n // Wait given amount of time\r\n await new Promise((response) => setTimeout(response, delayInMs));\r\n\r\n /// TO DO: Correct\r\n // // Information about the resource timeout\r\n // log(\r\n // 3,\r\n // `[utils] Waited ${delayInMs}ms until next call for the resource of ID: ${args[0]}.`\r\n // );\r\n\r\n // Try again\r\n return expBackoff(fn, attempt, ...args);\r\n }\r\n}\r\n\r\n/**\r\n * Checks if the given path is relative or absolute and returns the corrected,\r\n * absolute path.\r\n *\r\n * @function getAbsolutePath\r\n *\r\n * @param {string} path - The path to be checked on.\r\n *\r\n * @returns {string} The absolute path.\r\n */\r\nexport function getAbsolutePath(path) {\r\n return isAbsolute(path) ? normalize(path) : resolve(path);\r\n}\r\n\r\n/**\r\n * Converts input data to a Base64 string based on the export type.\r\n *\r\n * @function getBase64\r\n *\r\n * @param {string} input - The input to be transformed to Base64 format.\r\n * @param {string} type - The original export type.\r\n *\r\n * @returns {string} The Base64 string representation of the input.\r\n */\r\nexport function getBase64(input, type) {\r\n // For pdf and svg types the input must be transformed to Base64 from a buffer\r\n if (type === 'pdf' || type == 'svg') {\r\n return Buffer.from(input, 'utf8').toString('base64');\r\n }\r\n\r\n // For png and jpeg input is already a Base64 string\r\n return input;\r\n}\r\n\r\n/**\r\n * Returns stringified date without the GMT text information.\r\n *\r\n * @function getNewDate\r\n */\r\nexport function getNewDate() {\r\n // Get rid of the GMT text information\r\n return new Date().toString().split('(')[0].trim();\r\n}\r\n\r\n/**\r\n * Returns the stored time value in milliseconds.\r\n *\r\n * @function getNewDateTime\r\n */\r\nexport function getNewDateTime() {\r\n return new Date().getTime();\r\n}\r\n\r\n/**\r\n * Checks if the given item is an object.\r\n *\r\n * @function isObject\r\n *\r\n * @param {unknown} item - The item to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an object, `false`\r\n * otherwise.\r\n */\r\nexport function isObject(item) {\r\n return Object.prototype.toString.call(item) === '[object Object]';\r\n}\r\n\r\n/**\r\n * Checks if the given object is empty.\r\n *\r\n * @function isObjectEmpty\r\n *\r\n * @param {Object} item - The object to be checked.\r\n *\r\n * @returns {boolean} Returns `true` if the item is an empty object, `false`\r\n * otherwise.\r\n */\r\nexport function isObjectEmpty(item) {\r\n return (\r\n typeof item === 'object' &&\r\n !Array.isArray(item) &&\r\n item !== null &&\r\n Object.keys(item).length === 0\r\n );\r\n}\r\n\r\n/**\r\n * Checks if a private IP range URL is found in the given string.\r\n *\r\n * @function isPrivateRangeUrlFound\r\n *\r\n * @param {string} item - The string to be checked for a private IP range URL.\r\n *\r\n * @returns {boolean} Returns `true` if a private IP range URL is found, `false`\r\n * otherwise.\r\n */\r\nexport function isPrivateRangeUrlFound(item) {\r\n const regexPatterns = [\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?localhost\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?172\\.(1[6-9]|2[0-9]|3[0-1])\\.\\d{1,3}\\.\\d{1,3}\\b/,\r\n /xlink:href=\"(?:http:\\/\\/|https:\\/\\/)?192\\.168\\.\\d{1,3}\\.\\d{1,3}\\b/\r\n ];\r\n\r\n return regexPatterns.some((pattern) => pattern.test(item));\r\n}\r\n\r\n/**\r\n * Utility to measure elapsed time using the Node.js `process.hrtime()` method.\r\n *\r\n * @function measureTime\r\n *\r\n * @returns {Function} A function to calculate the elapsed time in milliseconds.\r\n */\r\nexport function measureTime() {\r\n const start = process.hrtime.bigint();\r\n return () => Number(process.hrtime.bigint() - start) / 1000000;\r\n}\r\n\r\n/**\r\n * Rounds a number to the specified precision.\r\n *\r\n * @function roundNumber\r\n *\r\n * @param {number} value - The number to be rounded.\r\n * @param {number} precision - The number of decimal places to round to.\r\n *\r\n * @returns {number} The rounded number.\r\n */\r\nexport function roundNumber(value, precision = 1) {\r\n const multiplier = Math.pow(10, precision || 0);\r\n return Math.round(+value * multiplier) / multiplier;\r\n}\r\n\r\n/**\r\n * Converts a value to a boolean.\r\n *\r\n * @function toBoolean\r\n *\r\n * @param {unknown} item - The value to be converted to a boolean.\r\n *\r\n * @returns {boolean} The boolean representation of the input value.\r\n */\r\nexport function toBoolean(item) {\r\n return ['false', 'undefined', 'null', 'NaN', '0', ''].includes(item)\r\n ? false\r\n : !!item;\r\n}\r\n\r\nexport default {\r\n __dirname,\r\n clearText,\r\n deepCopy,\r\n expBackoff,\r\n getAbsolutePath,\r\n getBase64,\r\n getNewDate,\r\n getNewDateTime,\r\n isObject,\r\n isObjectEmpty,\r\n isPrivateRangeUrlFound,\r\n measureTime,\r\n roundNumber,\r\n toBoolean\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module for managing logging functionality with customizable\r\n * log levels, console and file logging options, and error handling support.\r\n * The module also ensures that file-based logs are stored in a structured\r\n * directory, creating the necessary paths automatically if they do not exist.\r\n */\r\n\r\nimport { appendFile, existsSync, mkdirSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getAbsolutePath, getNewDate } from './utils.js';\r\n\r\n// The available colors\r\nconst colors = ['red', 'yellow', 'blue', 'gray', 'green'];\r\n\r\n// The default logging config\r\nconst logging = {\r\n // Flags for logging status\r\n toConsole: true,\r\n toFile: false,\r\n pathCreated: false,\r\n // Full path to the log file\r\n pathToLog: '',\r\n // Log levels\r\n levelsDesc: [\r\n {\r\n title: 'error',\r\n color: colors[0]\r\n },\r\n {\r\n title: 'warning',\r\n color: colors[1]\r\n },\r\n {\r\n title: 'notice',\r\n color: colors[2]\r\n },\r\n {\r\n title: 'verbose',\r\n color: colors[3]\r\n },\r\n {\r\n title: 'benchmark',\r\n color: colors[4]\r\n }\r\n ]\r\n};\r\n\r\n/**\r\n * Logs a message with a specified log level. Accepts a variable number\r\n * of arguments. The arguments after the `level` are passed to `console.log`\r\n * and/or used to construct and append messages to a log file.\r\n *\r\n * @function log\r\n *\r\n * @param {...unknown} args - An array of arguments where the first is the log\r\n * level and the remaining are strings used to build the log message.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function log(...args) {\r\n const [newLevel, ...texts] = args;\r\n\r\n // Current logging options\r\n const { levelsDesc, level } = logging;\r\n\r\n // Check if the log level is within a correct range or is it a benchmark log\r\n if (\r\n newLevel !== 5 &&\r\n (newLevel === 0 || newLevel > level || level > levelsDesc.length)\r\n ) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat(texts)\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message along with its stack trace. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logWithStack\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error} error - The error object containing the stack trace.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n *\r\n * @returns {void} Exits the function execution if attempting to log at a level\r\n * higher than allowed.\r\n */\r\nexport function logWithStack(newLevel, error, customMessage) {\r\n // Get the main message\r\n const mainMessage = customMessage || (error && error.message) || '';\r\n\r\n // Current logging options\r\n const { level, levelsDesc } = logging;\r\n\r\n // Check if the log level is within a correct range\r\n if (newLevel === 0 || newLevel > level || level > levelsDesc.length) {\r\n return;\r\n }\r\n\r\n // Create a message's prefix\r\n const prefix = `${getNewDate()} [${levelsDesc[newLevel - 1].title}] -`;\r\n\r\n // Add the whole stack message\r\n const stackMessage = error && error.stack;\r\n\r\n // Combine custom message or error message with error stack message, if exists\r\n const texts = [mainMessage];\r\n if (stackMessage) {\r\n texts.push('\\n', stackMessage);\r\n }\r\n\r\n // Log to file\r\n if (logging.toFile) {\r\n _logToFile(texts, prefix);\r\n }\r\n\r\n // Log to console\r\n if (logging.toConsole) {\r\n console.log.apply(\r\n undefined,\r\n [prefix.toString()[logging.levelsDesc[newLevel - 1].color]].concat([\r\n texts.shift()[colors[newLevel - 1]],\r\n ...texts\r\n ])\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Logs an error message related to Zod validation issues. Optionally, a custom\r\n * message can be provided.\r\n *\r\n * @function logZodIssues\r\n *\r\n * @param {number} newLevel - The log level.\r\n * @param {Error[]} issues - An array of Zod validation issues.\r\n * @param {string} customMessage - An optional custom message to be included\r\n * in the log alongside the error.\r\n */\r\nexport function logZodIssues(newLevel, issues, customMessage) {\r\n logWithStack(\r\n newLevel,\r\n null,\r\n [\r\n `${customMessage || '[validation] Validation error'} - the following Zod issues occured:`,\r\n ...(issues || []).map((issue) => `- ${issue.message}`)\r\n ].join('\\n')\r\n );\r\n}\r\n\r\n/**\r\n * Initializes logging with the specified logging configuration.\r\n *\r\n * @function initLogging\r\n *\r\n * @param {Object} loggingOptions - The configuration object containing\r\n * `logging` options.\r\n */\r\nexport function initLogging(loggingOptions) {\r\n // Get options from the `loggingOptions` object\r\n const { level, dest, file, toConsole, toFile } = loggingOptions;\r\n\r\n // Reset flags to the default values\r\n logging.pathCreated = false;\r\n logging.pathToLog = '';\r\n\r\n // Set the logging level\r\n setLogLevel(level);\r\n\r\n // Set the console logging\r\n enableConsoleLogging(toConsole);\r\n\r\n // Set the file logging\r\n enableFileLogging(dest, file, toFile);\r\n}\r\n\r\n/**\r\n * Sets the log level to the specified value. Log levels are (`0` = no logging,\r\n * `1` = error, `2` = warning, `3` = notice, `4` = verbose, or `5` = benchmark).\r\n *\r\n * @function setLogLevel\r\n *\r\n * @param {number} level - The log level to be set.\r\n */\r\nexport function setLogLevel(level) {\r\n if (\r\n Number.isInteger(level) &&\r\n level >= 0 &&\r\n level <= logging.levelsDesc.length\r\n ) {\r\n // Update the module logging's `level` option\r\n logging.level = level;\r\n }\r\n}\r\n\r\n/**\r\n * Enables console logging.\r\n *\r\n * @function enableConsoleLogging\r\n *\r\n * @param {boolean} toConsole - The flag for setting the logging to the console.\r\n */\r\nexport function enableConsoleLogging(toConsole) {\r\n // Update the module logging's `toConsole` option\r\n logging.toConsole = !!toConsole;\r\n}\r\n\r\n/**\r\n * Enables file logging with the specified destination and log file name.\r\n *\r\n * @function enableFileLogging\r\n *\r\n * @param {string} dest - The destination path where the log file should\r\n * be saved.\r\n * @param {string} file - The name of the log file.\r\n * @param {boolean} toFile - A flag indicating whether logging should\r\n * be directed to a file.\r\n */\r\nexport function enableFileLogging(dest, file, toFile) {\r\n // Update the module logging's `toFile` option\r\n logging.toFile = !!toFile;\r\n\r\n // Set the `dest` and `file` options only if the file logging is enabled\r\n if (logging.toFile) {\r\n logging.dest = dest || 'log';\r\n logging.file = file || 'highcharts-export-server.log';\r\n }\r\n}\r\n\r\n/**\r\n * Logs the provided texts to a file, if file logging is enabled. It creates\r\n * the necessary directory structure if not already created and appends\r\n * the content, including an optional prefix, to the specified log file.\r\n *\r\n * @function _logToFile\r\n *\r\n * @param {Array} texts - An array of texts to be logged.\r\n * @param {string} prefix - An optional prefix to be added to each log entry.\r\n */\r\nfunction _logToFile(texts, prefix) {\r\n if (!logging.pathCreated) {\r\n // Create if does not exist\r\n !existsSync(getAbsolutePath(logging.dest)) &&\r\n mkdirSync(getAbsolutePath(logging.dest));\r\n\r\n // Create the full path\r\n logging.pathToLog = getAbsolutePath(join(logging.dest, logging.file));\r\n\r\n // We now assume the path is available, e.g. it's the responsibility\r\n // of the user to create the path with the correct access rights.\r\n logging.pathCreated = true;\r\n }\r\n\r\n // Add the content to a file\r\n appendFile(\r\n logging.pathToLog,\r\n [prefix].concat(texts).join(' ') + '\\n',\r\n (error) => {\r\n if (error && logging.toFile && logging.pathCreated) {\r\n logging.toFile = false;\r\n logging.pathCreated = false;\r\n logWithStack(2, error, `[logger] Unable to write to log file.`);\r\n }\r\n }\r\n );\r\n}\r\n\r\nexport default {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n setLogLevel,\r\n enableConsoleLogging,\r\n enableFileLogging\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Configuration management module for the Highcharts Export Server.\r\n * It provides a default configuration object with predefined default values,\r\n * descriptions, and characteristics for each option used in the Export Server.\r\n */\r\n\r\n/**\r\n * The default configuration object containing all available options, organized\r\n * by sections.\r\n *\r\n * This object includes:\r\n * - Default values for each option.\r\n * - Data types for validation.\r\n * - Names of corresponding environment variables.\r\n * - Descriptions of each property.\r\n * - Information used for prompts in interactive configuration.\r\n * - [Optional] Corresponding CLI argument names for CLI usage.\r\n * - [Optional] Legacy names from the previous PhantomJS-based server.\r\n */\r\nconst defaultConfig = {\r\n puppeteer: {\r\n args: {\r\n value: [\r\n '--allow-running-insecure-content',\r\n '--ash-no-nudges',\r\n '--autoplay-policy=user-gesture-required',\r\n '--block-new-web-contents',\r\n '--disable-accelerated-2d-canvas',\r\n '--disable-background-networking',\r\n '--disable-background-timer-throttling',\r\n '--disable-backgrounding-occluded-windows',\r\n '--disable-breakpad',\r\n '--disable-checker-imaging',\r\n '--disable-client-side-phishing-detection',\r\n '--disable-component-extensions-with-background-pages',\r\n '--disable-component-update',\r\n '--disable-default-apps',\r\n '--disable-dev-shm-usage',\r\n '--disable-domain-reliability',\r\n '--disable-extensions',\r\n '--disable-features=CalculateNativeWinOcclusion,InterestFeedContentSuggestions,WebOTP',\r\n '--disable-hang-monitor',\r\n '--disable-ipc-flooding-protection',\r\n '--disable-logging',\r\n '--disable-notifications',\r\n '--disable-offer-store-unmasked-wallet-cards',\r\n '--disable-popup-blocking',\r\n '--disable-print-preview',\r\n '--disable-prompt-on-repost',\r\n '--disable-renderer-backgrounding',\r\n '--disable-search-engine-choice-screen',\r\n '--disable-session-crashed-bubble',\r\n '--disable-setuid-sandbox',\r\n '--disable-site-isolation-trials',\r\n '--disable-speech-api',\r\n '--disable-sync',\r\n '--enable-unsafe-webgpu',\r\n '--hide-crash-restore-bubble',\r\n '--hide-scrollbars',\r\n '--metrics-recording-only',\r\n '--mute-audio',\r\n '--no-default-browser-check',\r\n '--no-first-run',\r\n '--no-pings',\r\n '--no-sandbox',\r\n '--no-startup-window',\r\n '--no-zygote',\r\n '--password-store=basic',\r\n '--process-per-tab',\r\n '--use-mock-keychain'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'PUPPETEER_ARGS',\r\n cliName: 'puppeteerArgs',\r\n description: 'Array of Puppeteer arguments',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n highcharts: {\r\n version: {\r\n value: 'latest',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_VERSION',\r\n description: 'Highcharts version',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n cdnUrl: {\r\n value: 'https://code.highcharts.com',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CDN_URL',\r\n description: 'CDN URL for Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n forceFetch: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'HIGHCHARTS_FORCE_FETCH',\r\n description: 'Flag to refetch scripts after each server rerun',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n cachePath: {\r\n value: '.cache',\r\n types: ['string'],\r\n envLink: 'HIGHCHARTS_CACHE_PATH',\r\n description: 'Directory path for cached Highcharts scripts',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n coreScripts: {\r\n value: ['highcharts', 'highcharts-more', 'highcharts-3d'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CORE_SCRIPTS',\r\n description: 'Highcharts core scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n moduleScripts: {\r\n value: [\r\n 'stock',\r\n 'map',\r\n 'gantt',\r\n 'exporting',\r\n 'parallel-coordinates',\r\n 'accessibility',\r\n // 'annotations-advanced',\r\n 'boost-canvas',\r\n 'boost',\r\n 'data',\r\n 'data-tools',\r\n 'draggable-points',\r\n 'static-scale',\r\n 'broken-axis',\r\n 'heatmap',\r\n 'tilemap',\r\n 'tiledwebmap',\r\n 'timeline',\r\n 'treemap',\r\n 'treegraph',\r\n 'item-series',\r\n 'drilldown',\r\n 'histogram-bellcurve',\r\n 'bullet',\r\n 'funnel',\r\n 'funnel3d',\r\n 'geoheatmap',\r\n 'pyramid3d',\r\n 'networkgraph',\r\n 'overlapping-datalabels',\r\n 'pareto',\r\n 'pattern-fill',\r\n 'pictorial',\r\n 'price-indicator',\r\n 'sankey',\r\n 'arc-diagram',\r\n 'dependency-wheel',\r\n 'series-label',\r\n 'series-on-point',\r\n 'solid-gauge',\r\n 'sonification',\r\n // 'stock-tools',\r\n 'streamgraph',\r\n 'sunburst',\r\n 'variable-pie',\r\n 'variwide',\r\n 'vector',\r\n 'venn',\r\n 'windbarb',\r\n 'wordcloud',\r\n 'xrange',\r\n 'no-data-to-display',\r\n 'drag-panes',\r\n 'debugger',\r\n 'dumbbell',\r\n 'lollipop',\r\n 'cylinder',\r\n 'organization',\r\n 'dotplot',\r\n 'marker-clusters',\r\n 'hollowcandlestick',\r\n 'heikinashi',\r\n 'flowmap',\r\n 'export-data',\r\n 'navigator',\r\n 'textpath'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_MODULE_SCRIPTS',\r\n description: 'Highcharts module scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n indicatorScripts: {\r\n value: ['indicators-all'],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_INDICATOR_SCRIPTS',\r\n description: 'Highcharts indicator scripts to fetch',\r\n promptOptions: {\r\n type: 'multiselect',\r\n instructions: 'Space: Select specific, A: Select all, Enter: Confirm'\r\n }\r\n },\r\n customScripts: {\r\n value: [\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.30.1/moment.min.js',\r\n 'https://cdnjs.cloudflare.com/ajax/libs/moment-timezone/0.5.45/moment-timezone-with-data.min.js'\r\n ],\r\n types: ['string[]'],\r\n envLink: 'HIGHCHARTS_CUSTOM_SCRIPTS',\r\n description: 'Additional custom scripts or dependencies to fetch',\r\n promptOptions: {\r\n type: 'list',\r\n separator: ';'\r\n }\r\n }\r\n },\r\n export: {\r\n infile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_INFILE',\r\n description:\r\n 'Input filename with type, formatted correctly as JSON or SVG',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n instr: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_INSTR',\r\n description:\r\n 'Overrides the `infile` with JSON, stringified JSON, or SVG input',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n options: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_OPTIONS',\r\n description: 'Alias for the `instr` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n svg: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_SVG',\r\n description: 'SVG string representation of the chart to render',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n batch: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_BATCH',\r\n description:\r\n 'Batch job string with input/output pairs: \"in=out;in=out;...\"',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n outfile: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'EXPORT_OUTFILE',\r\n description:\r\n 'Output filename with type. Can be jpeg, png, pdf, or svg and ignores `type` option',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n type: {\r\n value: 'png',\r\n types: ['string'],\r\n envLink: 'EXPORT_TYPE',\r\n description: 'File export format. Can be jpeg, png, pdf, or svg',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: png',\r\n choices: ['png', 'jpeg', 'pdf', 'svg']\r\n }\r\n },\r\n constr: {\r\n value: 'chart',\r\n types: ['string'],\r\n envLink: 'EXPORT_CONSTR',\r\n description:\r\n 'Chart constructor. Can be chart, stockChart, mapChart, or ganttChart',\r\n promptOptions: {\r\n type: 'select',\r\n hint: 'Default: chart',\r\n choices: ['chart', 'stockChart', 'mapChart', 'ganttChart']\r\n }\r\n },\r\n b64: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_B64',\r\n description:\r\n 'Whether or not to the chart should be received in Base64 format instead of binary',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noDownload: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'EXPORT_NO_DOWNLOAD',\r\n description:\r\n 'Whether or not to include or exclude attachment headers in the response',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n height: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_HEIGHT',\r\n description: 'Height of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n width: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_WIDTH',\r\n description: 'Width of the exported chart, overrides chart settings',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n scale: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'EXPORT_SCALE',\r\n description:\r\n 'Scale of the exported chart, overrides chart settings. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultHeight: {\r\n value: 400,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_HEIGHT',\r\n description: 'Default height of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultWidth: {\r\n value: 600,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_WIDTH',\r\n description: 'Default width of the exported chart if not set',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n defaultScale: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'EXPORT_DEFAULT_SCALE',\r\n description:\r\n 'Default scale of the exported chart if not set. Ranges from 0.1 to 5.0',\r\n promptOptions: {\r\n type: 'number',\r\n min: 0.1,\r\n max: 5\r\n }\r\n },\r\n globalOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_GLOBAL_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with global options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n themeOptions: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'EXPORT_THEME_OPTIONS',\r\n description:\r\n 'JSON, stringified JSON or filename with theme options for Highcharts.setOptions',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n rasterizationTimeout: {\r\n value: 1500,\r\n types: ['number'],\r\n envLink: 'EXPORT_RASTERIZATION_TIMEOUT',\r\n description: 'Milliseconds to wait for webpage rendering',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n customLogic: {\r\n allowCodeExecution: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_CODE_EXECUTION',\r\n description:\r\n 'Allows or disallows execution of arbitrary code during exporting',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n allowFileResources: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'CUSTOM_LOGIC_ALLOW_FILE_RESOURCES',\r\n description:\r\n 'Allows or disallows injection of filesystem resources (disabled in server mode)',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n customCode: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CUSTOM_CODE',\r\n description:\r\n 'Custom code to execute before chart initialization. Can be a function, code wrapped in a function, or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n callback: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CALLBACK',\r\n description:\r\n 'JavaScript code to run during construction. Can be a function or a .js filename',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n resources: {\r\n value: null,\r\n types: ['Object', 'string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_RESOURCES',\r\n description:\r\n 'Additional resources as JSON, stringified JSON, or filename, containing files, js, and css sections',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n loadConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_LOAD_CONFIG',\r\n legacyName: 'fromFile',\r\n description: 'File with a pre-defined configuration to use',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n createConfig: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'CUSTOM_LOGIC_CREATE_CONFIG',\r\n description:\r\n 'Prompt-based option setting, saved to a provided config file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n server: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_ENABLE',\r\n cliName: 'enableServer',\r\n description: 'Starts the server when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n host: {\r\n value: '0.0.0.0',\r\n types: ['string'],\r\n envLink: 'SERVER_HOST',\r\n description: 'Hostname of the server',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: 7801,\r\n types: ['number'],\r\n envLink: 'SERVER_PORT',\r\n description: 'Port number for the server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n uploadLimit: {\r\n value: 3,\r\n types: ['number'],\r\n envLink: 'SERVER_UPLOAD_LIMIT',\r\n description: 'Maximum request body size in MB',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_BENCHMARKING',\r\n cliName: 'serverBenchmarking',\r\n description:\r\n 'Displays or not action durations in milliseconds during server requests',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n proxy: {\r\n host: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_PROXY_HOST',\r\n cliName: 'proxyHost',\r\n description: 'Host of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n port: {\r\n value: null,\r\n types: ['number', 'null'],\r\n envLink: 'SERVER_PROXY_PORT',\r\n cliName: 'proxyPort',\r\n description: 'Port of the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n timeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'SERVER_PROXY_TIMEOUT',\r\n cliName: 'proxyTimeout',\r\n description:\r\n 'Timeout in milliseconds for the proxy server, if applicable',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n },\r\n rateLimiting: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_ENABLE',\r\n cliName: 'enableRateLimiting',\r\n description: 'Enables or disables rate limiting on the server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n maxRequests: {\r\n value: 10,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_MAX_REQUESTS',\r\n legacyName: 'rateLimit',\r\n description: 'Maximum number of requests allowed per minute',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n window: {\r\n value: 1,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_WINDOW',\r\n description: 'Time window in minutes for rate limiting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n delay: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'SERVER_RATE_LIMITING_DELAY',\r\n description:\r\n 'Delay duration between successive requests before reaching the limit',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n trustProxy: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_RATE_LIMITING_TRUST_PROXY',\r\n description: 'Set to true if the server is behind a load balancer',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n skipKey: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_KEY',\r\n description: 'Key to bypass the rate limiter, used with `skipToken`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n skipToken: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_RATE_LIMITING_SKIP_TOKEN',\r\n description: 'Token to bypass the rate limiter, used with `skipKey`',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n ssl: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_ENABLE',\r\n cliName: 'enableSsl',\r\n description: 'Enables or disables SSL protocol',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n force: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'SERVER_SSL_FORCE',\r\n cliName: 'sslForce',\r\n legacyName: 'sslOnly',\r\n description: 'Forces the server to use HTTPS only when true',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n port: {\r\n value: 443,\r\n types: ['number'],\r\n envLink: 'SERVER_SSL_PORT',\r\n cliName: 'sslPort',\r\n description: 'Port for the SSL server',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n certPath: {\r\n value: null,\r\n types: ['string', 'null'],\r\n envLink: 'SERVER_SSL_CERT_PATH',\r\n cliName: 'sslCertPath',\r\n legacyName: 'sslPath',\r\n description: 'Path to the SSL certificate/key file',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n }\r\n },\r\n pool: {\r\n minWorkers: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'POOL_MIN_WORKERS',\r\n description: 'Minimum and initial number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n maxWorkers: {\r\n value: 8,\r\n types: ['number'],\r\n envLink: 'POOL_MAX_WORKERS',\r\n legacyName: 'workers',\r\n description: 'Maximum number of pool workers to spawn',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n workLimit: {\r\n value: 40,\r\n types: ['number'],\r\n envLink: 'POOL_WORK_LIMIT',\r\n description: 'Number of tasks a worker can handle before restarting',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n acquireTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_ACQUIRE_TIMEOUT',\r\n description: 'Timeout in milliseconds for acquiring a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_TIMEOUT',\r\n description: 'Timeout in milliseconds for creating a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n destroyTimeout: {\r\n value: 5000,\r\n types: ['number'],\r\n envLink: 'POOL_DESTROY_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying a resource',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n idleTimeout: {\r\n value: 30000,\r\n types: ['number'],\r\n envLink: 'POOL_IDLE_TIMEOUT',\r\n description: 'Timeout in milliseconds for destroying idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n createRetryInterval: {\r\n value: 200,\r\n types: ['number'],\r\n envLink: 'POOL_CREATE_RETRY_INTERVAL',\r\n description:\r\n 'Interval in milliseconds before retrying resource creation on failure',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n reaperInterval: {\r\n value: 1000,\r\n types: ['number'],\r\n envLink: 'POOL_REAPER_INTERVAL',\r\n description:\r\n 'Interval in milliseconds to check and destroy idle resources',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n benchmarking: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'POOL_BENCHMARKING',\r\n cliName: 'poolBenchmarking',\r\n description: 'Shows statistics for the pool of resources',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n logging: {\r\n level: {\r\n value: 4,\r\n types: ['number'],\r\n envLink: 'LOGGING_LEVEL',\r\n cliName: 'logLevel',\r\n description: 'Logging verbosity level',\r\n promptOptions: {\r\n type: 'number',\r\n round: 0,\r\n min: 0,\r\n max: 5\r\n }\r\n },\r\n file: {\r\n value: 'highcharts-export-server.log',\r\n types: ['string'],\r\n envLink: 'LOGGING_FILE',\r\n cliName: 'logFile',\r\n description:\r\n 'Log file name. Requires `logToFile` and `logDest` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n dest: {\r\n value: 'log',\r\n types: ['string'],\r\n envLink: 'LOGGING_DEST',\r\n cliName: 'logDest',\r\n description: 'Path to store log files. Requires `logToFile` to be set',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n toConsole: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_CONSOLE',\r\n cliName: 'logToConsole',\r\n description: 'Enables or disables console logging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n toFile: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'LOGGING_TO_FILE',\r\n cliName: 'logToFile',\r\n description: 'Enables or disables logging to a file',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n ui: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'UI_ENABLE',\r\n cliName: 'enableUi',\r\n description: 'Enables or disables the UI for the export server',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n route: {\r\n value: '/',\r\n types: ['string'],\r\n envLink: 'UI_ROUTE',\r\n cliName: 'uiRoute',\r\n description: 'The endpoint route for the UI',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n }\r\n },\r\n other: {\r\n nodeEnv: {\r\n value: 'production',\r\n types: ['string'],\r\n envLink: 'OTHER_NODE_ENV',\r\n description: 'The Node.js environment type',\r\n promptOptions: {\r\n type: 'text'\r\n }\r\n },\r\n listenToProcessExits: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_LISTEN_TO_PROCESS_EXITS',\r\n description: 'Whether or not to attach process.exit handlers',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n noLogo: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_NO_LOGO',\r\n description: 'Display or skip printing the logo on startup',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n hardResetPage: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'OTHER_HARD_RESET_PAGE',\r\n description: 'Whether or not to reset the page content entirely',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n browserShellMode: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_BROWSER_SHELL_MODE',\r\n description: 'Whether or not to set the browser to run in shell mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n validation: {\r\n value: true,\r\n types: ['boolean'],\r\n envLink: 'OTHER_VALIDATION',\r\n description: 'Whether or not to enable validation of options types',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n }\r\n },\r\n debug: {\r\n enable: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_ENABLE',\r\n cliName: 'enableDebug',\r\n description: 'Enables or disables debug mode for the underlying browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n headless: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_HEADLESS',\r\n description:\r\n 'Whether or not to set the browser to run in headless mode during debugging',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n devtools: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DEVTOOLS',\r\n description: 'Enables or disables DevTools in headful mode',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n listenToConsole: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_LISTEN_TO_CONSOLE',\r\n description:\r\n 'Enables or disables listening to console messages from the browser',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n dumpio: {\r\n value: false,\r\n types: ['boolean'],\r\n envLink: 'DEBUG_DUMPIO',\r\n description:\r\n 'Redirects or not browser stdout and stderr to process.stdout and process.stderr',\r\n promptOptions: {\r\n type: 'toggle'\r\n }\r\n },\r\n slowMo: {\r\n value: 0,\r\n types: ['number'],\r\n envLink: 'DEBUG_SLOW_MO',\r\n description: 'Delays Puppeteer operations by the specified milliseconds',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n },\r\n debuggingPort: {\r\n value: 9222,\r\n types: ['number'],\r\n envLink: 'DEBUG_DEBUGGING_PORT',\r\n description: 'Port used for debugging',\r\n promptOptions: {\r\n type: 'number'\r\n }\r\n }\r\n }\r\n};\r\n\r\nexport default defaultConfig;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This file handles parsing and validating options from multiple\r\n * sources (the config file, custom JSON, environment variables, CLI arguments,\r\n * and request payload) using the 'zod' library.\r\n *\r\n * Environment variables are parsed and validated only once at application\r\n * startup, and the validated results are exported as `envs` for use throughout\r\n * the application.\r\n *\r\n * Options from other sources, however, are parsed and validated on demand,\r\n * each time an export is attempted.\r\n */\r\n\r\nimport dotenv from 'dotenv';\r\nimport { z } from 'zod';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\n// Load the .env into environment variables\r\ndotenv.config();\r\n\r\n// Get scripts names of each category from the default config\r\nconst { coreScripts, moduleScripts, indicatorScripts } =\r\n defaultConfig.highcharts;\r\n\r\n// Sets the custom error map globally\r\nz.setErrorMap(_customErrorMap);\r\n\r\n/**\r\n * Object containing custom general validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nconst v = {\r\n /**\r\n * The `boolean` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept values are true\r\n * and false and the schema will validate against the default boolean\r\n * validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept values are true,\r\n * false, null, 'true', '1', 'false', '0', 'undefined', 'null', and ''.\r\n * The strings 'undefined', 'null', and '' will be transformed to null,\r\n * the string 'true' will be transformed to the boolean value true,\r\n * and 'false' will be transformed to the boolean value false.\r\n *\r\n * @function boolean\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating boolean values.\r\n */\r\n boolean(strictCheck) {\r\n return strictCheck\r\n ? z.boolean()\r\n : z\r\n .union([\r\n z\r\n .enum(['true', '1', 'false', '0', 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? value === 'true' || value === '1'\r\n : null\r\n ),\r\n z.boolean()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `string` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed strings except\r\n * the forbidden values: 'false', 'undefined', 'null', and ''.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed strings\r\n * and null. The forbidden values: 'false', 'undefined', 'null', and '' will\r\n * be transformed to null.\r\n *\r\n * @function string\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating string values.\r\n */\r\n string(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The string contains a forbidden value'\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .transform((value) =>\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `enum` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `values` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will validate against the `values`\r\n * array with the default enum validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', and '', which will be transformed to null.\r\n *\r\n * @function enum\r\n *\r\n * @param {Array.} values - An array of valid string values\r\n * for the enum.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating enum values.\r\n */\r\n enum(values, strictCheck) {\r\n return strictCheck\r\n ? z.enum([...values])\r\n : z\r\n .enum([...values, 'undefined', 'null', ''])\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `stringArray` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept an array of trimmed\r\n * string values filtered by the logic provided through the `filterCallback`.\r\n *\r\n * - When `strictCheck` is false, the schema will accept null and trimmed\r\n * string values which will be splitted into an array of strings and filtered\r\n * from the '[' and ']' characters and by the logic provided through\r\n * the `filterCallback`. If the array is empty, it will be transformed\r\n * to null.\r\n *\r\n * @function stringArray\r\n *\r\n * @param {function} filterCallback - The filter callback.\r\n * @param {string} separator - The separator for spliting a string.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating array of string\r\n * values.\r\n */\r\n stringArray(filterCallback, separator, strictCheck) {\r\n const arraySchema = z.string().trim().array();\r\n const stringSchema = z\r\n .string()\r\n .trim()\r\n .transform((value) => {\r\n if (value.startsWith('[')) {\r\n value = value.slice(1);\r\n }\r\n if (value.endsWith(']')) {\r\n value = value.slice(0, -1);\r\n }\r\n return value.split(separator);\r\n });\r\n\r\n const transformCallback = (value) =>\r\n value.map((value) => value.trim()).filter(filterCallback);\r\n\r\n return strictCheck\r\n ? arraySchema.transform(transformCallback)\r\n : z\r\n .union([stringSchema, arraySchema])\r\n .transform(transformCallback)\r\n .transform((value) => (value.length ? value : null))\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `positiveNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept positive number values\r\n * and validate against the default positive number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept positive number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a positive number. It will transform the string\r\n * to a positive number, or to null if it is 'undefined', 'null', or ''.\r\n *\r\n * @function positiveNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating positive number\r\n * values.\r\n */\r\n positiveNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().positive()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) > 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and positive'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().positive()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `nonNegativeNum` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept non-negative number\r\n * values and validate against the default non-negative number validator.\r\n *\r\n * - When `strictCheck` is false, the schema will accept non-negative number\r\n * values, null, and trimmed string values that can either be 'undefined',\r\n * 'null', '', or represent a non-negative number. It will transform\r\n * the string to a non-negative number, or to null if it is 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function nonNegativeNum\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating non-negative\r\n * number values.\r\n */\r\n nonNegativeNum(strictCheck) {\r\n return strictCheck\r\n ? z.number().nonnegative()\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) && Number(value) >= 0) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be numeric and non-negative'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().nonnegative()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `startsWith` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The schema will validate against the provided `prefixes` array to check\r\n * whether a string value starts with any of the values provided\r\n * in the `prefixes` array.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that start with values from the prefixes array.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that start with values from the prefixes array, null, 'undefined', 'null',\r\n * and '' where the schema will transform them to null.\r\n *\r\n * @function startsWith\r\n *\r\n * @param {Array.} prefixes - An array of prefixes to validate\r\n * the string against.\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating strings that\r\n * starts with values.\r\n */\r\n startsWith(prefixes, strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) => prefixes.some((prefix) => value.startsWith(prefix)),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n prefixes.some((prefix) => value.startsWith(prefix)) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: `The value must be a string that starts with ${prefixes.join(', ')}`\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `chartConfig` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `additionalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that end with '.json' and are at least one\r\n * character long excluding the extension, start with the '{' and end\r\n * with the '}', and null. The 'undefined', 'null', and '' values will\r\n * be transformed to null.\r\n *\r\n * @function additionalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating additional chart\r\n * options value.\r\n */\r\n additionalOptions() {\r\n return z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that ends with '.json' or starts with '{' and ends with '}'\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n ),\r\n z.object({}).passthrough()\r\n ])\r\n .nullable();\r\n }\r\n};\r\n\r\n/**\r\n * Object containing custom config validators and parsers to avoid repetition\r\n * in schema objects. All validators apply to values from various sources,\r\n * including the default config file, a custom JSON file loaded with the option\r\n * called `loadConfig`, the .env file, CLI arguments, and the request payload.\r\n * The `strictCheck` flag enables stricter validation and parsing rules. This\r\n * flag is set to false for values that come from the .env file or CLI arguments\r\n * because they are provided as strings and need to be parsed accordingly first.\r\n */\r\nexport const validators = {\r\n /**\r\n * The `args` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function args\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `args`\r\n * option.\r\n */\r\n args(strictCheck) {\r\n return v.stringArray(\r\n (value) => !['false', 'undefined', 'null', ''].includes(value),\r\n ';',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `version` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that are a RegExp-based that allows to be 'latest', or in the format XX,\r\n * XX.YY, or XX.YY.ZZ, where XX, YY, and ZZ are numeric for the Highcharts\r\n * version option.\r\n *\r\n * - When `strictCheck` is false, the schema will accept also null,\r\n * 'undefined', 'null', or '' and in all cases the schema will transform them\r\n * to null.\r\n *\r\n * @function version\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `version`\r\n * option.\r\n */\r\n version(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine((value) => /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value), {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n })\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n /^(latest|\\d{1,2}(\\.\\d{1,2}){0,2})$/.test(value) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be 'latest', a major version, or in the form XX.YY.ZZ\"\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `cdnUrl` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function cdnUrl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cdnUrl`\r\n * option.\r\n */\r\n cdnUrl(strictCheck) {\r\n return v.startsWith(['http://', 'https://'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `forceFetch` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function forceFetch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `forceFetch`\r\n * option.\r\n */\r\n forceFetch(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `cachePath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function cachePath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `cachePath`\r\n * option.\r\n */\r\n cachePath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `adminToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function adminToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `adminToken`\r\n * option.\r\n */\r\n adminToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `coreScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function coreScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `coreScripts`\r\n * option.\r\n */\r\n coreScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => coreScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `moduleScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function moduleScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `moduleScripts` option.\r\n */\r\n moduleScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => moduleScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `indicatorScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function indicatorScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `indicatorScripts` option.\r\n */\r\n indicatorScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => indicatorScripts.value.includes(value),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `customScripts` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `stringArray` validator.\r\n *\r\n * @function customScripts\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `customScripts` option.\r\n */\r\n customScripts(strictCheck) {\r\n return v.stringArray(\r\n (value) => value.startsWith('https://') || value.startsWith('http://'),\r\n ',',\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `infile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.json' or '.svg', are at least one character long excluding\r\n * the extension and will be null if the provided value is null, 'undefined',\r\n * 'null', or ''.\r\n *\r\n * @function infile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `infile`\r\n * option.\r\n */\r\n infile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n (value.length >= 5 && value.endsWith('.svg')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .json or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `instr` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function instr\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `instr`\r\n * option.\r\n */\r\n instr() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `options` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `options` validator.\r\n *\r\n * @function options\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `options`\r\n * option.\r\n */\r\n options() {\r\n return v.chartConfig();\r\n },\r\n\r\n /**\r\n * The `svg` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures that the schema will accept object values\r\n * or trimmed string values that contain '\r\n value.indexOf('= 0 ||\r\n value.indexOf('= 0 ||\r\n ['false', 'undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that contains '\r\n !['false', 'undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `outfile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension, or null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept trimmed string values\r\n * that end with '.jpeg', '.jpg', '.png', '.pdf', or '.svg', are at least one\r\n * character long excluding the extension and will be null if the provided\r\n * value is null, 'undefined', 'null', or ''.\r\n *\r\n * @function outfile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `outfile`\r\n * option.\r\n */\r\n outfile(strictCheck) {\r\n return strictCheck\r\n ? z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .nullable()\r\n : z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.length >= 6 && value.endsWith('.jpeg')) ||\r\n (value.length >= 5 &&\r\n (value.endsWith('.jpg') ||\r\n value.endsWith('.png') ||\r\n value.endsWith('.pdf') ||\r\n value.endsWith('.svg'))) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage:\r\n 'The value must be a string that ends with .jpeg, .jpg, .png, .pdf, or .svg'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n )\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `type` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function type\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `type`\r\n * option.\r\n */\r\n type(strictCheck) {\r\n return v.enum(['jpeg', 'jpg', 'png', 'pdf', 'svg'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `constr` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function constr\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `constr`\r\n * option.\r\n */\r\n constr(strictCheck) {\r\n return v.enum(\r\n ['chart', 'stockChart', 'mapChart', 'ganttChart'],\r\n strictCheck\r\n );\r\n },\r\n\r\n /**\r\n * The `b64` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function b64\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `b64` option.\r\n */\r\n b64(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noDownload` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noDownload\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noDownload`\r\n * option.\r\n */\r\n noDownload(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultHeight` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultHeight\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultHeight` option.\r\n */\r\n defaultHeight(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultWidth` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function defaultWidth\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultWidth` option.\r\n */\r\n defaultWidth(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `defaultScale` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept number values that\r\n * are between 0.1 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept number values\r\n * and stringified number values that are between 0.1 and 5 (inclusive), null,\r\n * 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function defaultScale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `defaultScale` option.\r\n */\r\n defaultScale(strictCheck) {\r\n return strictCheck\r\n ? z.number().gte(0.1).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number(value) >= 0.1 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0.1 and 5.0 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().gte(0.1).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `height` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultHeight`\r\n * validator.\r\n *\r\n * @function height\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `height`\r\n * option.\r\n */\r\n height(strictCheck) {\r\n return this.defaultHeight(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `width` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultWidth`\r\n * validator.\r\n *\r\n * @function width\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `width`\r\n * option.\r\n */\r\n width(strictCheck) {\r\n return this.defaultWidth(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `scale` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `defaultScale`\r\n * validator.\r\n *\r\n * @function scale\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `scale`\r\n * option.\r\n */\r\n scale(strictCheck) {\r\n return this.defaultScale(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `globalOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function globalOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `globalOptions` option.\r\n */\r\n globalOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `themeOptions` validator that returns a Zod schema.\r\n *\r\n * The validation schema ensures the same work as the `additionalOptions`\r\n * validator.\r\n *\r\n * @function themeOptions\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `themeOptions` option.\r\n */\r\n themeOptions() {\r\n return v.additionalOptions();\r\n },\r\n\r\n /**\r\n * The `batch` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function batch\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `batch`\r\n * option.\r\n */\r\n batch(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `rasterizationTimeout` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function rasterizationTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `rasterizationTimeout` option.\r\n */\r\n rasterizationTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowCodeExecution` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowCodeExecution\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowCodeExecution` option.\r\n */\r\n allowCodeExecution(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `allowFileResources` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function allowFileResources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `allowFileResources` option.\r\n */\r\n allowFileResources(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `customCode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function customCode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `customCode`\r\n * option.\r\n */\r\n customCode(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `callback` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function callback\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `callback`\r\n * option.\r\n */\r\n callback(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resources` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept a partial object\r\n * with allowed properties `js`, `css`, and `files` where each of the allowed\r\n * properties can be null, stringified version of the object, string that ends\r\n * with the '.json', and null.\r\n *\r\n * - When `strictCheck` is false, the schema will accept a stringified version\r\n * of a partial object with allowed properties `js`, `css`, and `files` where\r\n * each of the allowed properties can be null, string that ends with the\r\n * '.json', and will be null if the provided value is 'undefined', 'null'\r\n * or ''.\r\n *\r\n * @function resources\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `resources`\r\n * option.\r\n */\r\n resources(strictCheck) {\r\n const objectSchema = z\r\n .object({\r\n js: v.string(false),\r\n css: v.string(false),\r\n files: v\r\n .stringArray(\r\n (value) => !['undefined', 'null', ''].includes(value),\r\n ',',\r\n true\r\n )\r\n .nullable()\r\n })\r\n .partial();\r\n\r\n const stringSchema1 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage:\r\n \"The value must be a string that starts with '{' and ends with '}\"\r\n }\r\n }\r\n );\r\n\r\n const stringSchema2 = z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (value.startsWith('{') && value.endsWith('}')) ||\r\n (value.length >= 6 && value.endsWith('.json')) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value) ? value : null\r\n );\r\n\r\n return strictCheck\r\n ? z.union([objectSchema, stringSchema1]).nullable()\r\n : z.union([objectSchema, stringSchema2]).nullable();\r\n },\r\n\r\n /**\r\n * The `loadConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.json'.\r\n *\r\n * @function loadConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `loadConfig`\r\n * option.\r\n */\r\n loadConfig(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 6 && value.endsWith('.json')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .json'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `createConfig` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `loadConfig` validator.\r\n *\r\n * @function createConfig\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createConfig` option.\r\n */\r\n createConfig(strictCheck) {\r\n return this.loadConfig(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableServer` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableServer\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableServer` option.\r\n */\r\n enableServer(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `host` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function host\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `host`\r\n * option.\r\n */\r\n host(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `port` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function port\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `port`\r\n * option.\r\n */\r\n port(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uploadLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function uploadLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uploadLimit`\r\n * option.\r\n */\r\n uploadLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `serverBenchmarking` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function serverBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `serverBenchmarking` option.\r\n */\r\n serverBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyHost` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function proxyHost\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyHost`\r\n * option.\r\n */\r\n proxyHost(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `proxyPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as a nullable `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `proxyPort`\r\n * option.\r\n */\r\n proxyPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck).nullable();\r\n },\r\n\r\n /**\r\n * The `proxyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function proxyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `proxyTimeout` option.\r\n */\r\n proxyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableRateLimiting` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `enableRateLimiting` option.\r\n */\r\n enableRateLimiting(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxRequests` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function maxRequests\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxRequests`\r\n * option.\r\n */\r\n maxRequests(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `window` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function window\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `window`\r\n * option.\r\n */\r\n window(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `delay` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function delay\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `delay`\r\n * option.\r\n */\r\n delay(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `trustProxy` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function trustProxy\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `trustProxy`\r\n * option.\r\n */\r\n trustProxy(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipKey` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipKey\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipKey`\r\n * option.\r\n */\r\n skipKey(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `skipToken` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function skipToken\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `skipToken`\r\n * option.\r\n */\r\n skipToken(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableSsl` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableSsl\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableSsl`\r\n * option.\r\n */\r\n enableSsl(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslForce` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function sslForce\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslForce`\r\n * option.\r\n */\r\n sslForce(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslPort` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function sslPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslPort`\r\n * option.\r\n */\r\n sslPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `sslCertPath` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function sslCertPath\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `sslCertPath`\r\n * option.\r\n */\r\n sslCertPath(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `minWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function minWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `minWorkers`\r\n * option.\r\n */\r\n minWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `maxWorkers` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function maxWorkers\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `maxWorkers`\r\n * option.\r\n */\r\n maxWorkers(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `workLimit` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `positiveNum` validator.\r\n *\r\n * @function workLimit\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `workLimit`\r\n * option.\r\n */\r\n workLimit(strictCheck) {\r\n return v.positiveNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `acquireTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function acquireTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `acquireTimeout` option.\r\n */\r\n acquireTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createTimeout` option.\r\n */\r\n createTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `destroyTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function destroyTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `destroyTimeout` option.\r\n */\r\n destroyTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `idleTimeout` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function idleTimeout\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `idleTimeout` option.\r\n */\r\n idleTimeout(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `createRetryInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function createRetryInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `createRetryInterval` option.\r\n */\r\n createRetryInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `reaperInterval` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function reaperInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `reaperInterval` option.\r\n */\r\n reaperInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `poolBenchmarking` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function poolBenchmarking\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `poolBenchmarking` option.\r\n */\r\n poolBenchmarking(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `resourcesInterval` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function resourcesInterval\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `resourcesInterval` option.\r\n */\r\n resourcesInterval(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logLevel` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures that:\r\n *\r\n * - When `strictCheck` is true, the schema will accept integer number values\r\n * that are between 0 and 5 (inclusive).\r\n *\r\n * - When `strictCheck` is false, the schema will accept integer number values\r\n * and stringified integer number values that are between 1 and 5 (inclusive),\r\n * null, 'undefined', 'null', and '' which will be transformed to null.\r\n *\r\n * @function logLevel\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logLevel`\r\n * option.\r\n */\r\n logLevel(strictCheck) {\r\n return strictCheck\r\n ? z.number().int().gte(0).lte(5)\r\n : z\r\n .union([\r\n z\r\n .string()\r\n .trim()\r\n .refine(\r\n (value) =>\r\n (!isNaN(Number(value)) &&\r\n value !== true &&\r\n !value.startsWith('[') &&\r\n Number.isInteger(Number(value)) &&\r\n Number(value) >= 0 &&\r\n Number(value) <= 5) ||\r\n ['undefined', 'null', ''].includes(value),\r\n {\r\n params: {\r\n errorMessage: 'The value must be within a 0 and 5 range'\r\n }\r\n }\r\n )\r\n .transform((value) =>\r\n !['undefined', 'null', ''].includes(value)\r\n ? Number(value)\r\n : null\r\n ),\r\n z.number().int().gte(0).lte(5)\r\n ])\r\n .nullable();\r\n },\r\n\r\n /**\r\n * The `logFile` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a string that ends with '.log'.\r\n *\r\n * @function logFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logFile`\r\n * option.\r\n */\r\n logFile(strictCheck) {\r\n return v\r\n .string(strictCheck)\r\n .refine(\r\n (value) =>\r\n value === null || (value.length >= 5 && value.endsWith('.log')),\r\n {\r\n params: {\r\n errorMessage: 'The value must be a string that ends with .log'\r\n }\r\n }\r\n );\r\n },\r\n\r\n /**\r\n * The `logDest` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n *\r\n * @function logDest\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logDest`\r\n * option.\r\n */\r\n logDest(strictCheck) {\r\n return v.string(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `logToConsole` option.\r\n */\r\n logToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `logToFile` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function logToFile\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `logToFile`\r\n * option.\r\n */\r\n logToFile(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableUi` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableUi\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableUi`\r\n * option.\r\n */\r\n enableUi(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `uiRoute` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `startsWith` validator.\r\n *\r\n * @function uiRoute\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `uiRoute`\r\n * option.\r\n */\r\n uiRoute(strictCheck) {\r\n return v.startsWith(['/'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `nodeEnv` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `enum` validator.\r\n *\r\n * @function nodeEnv\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `nodeEnv`\r\n * option.\r\n */\r\n nodeEnv(strictCheck) {\r\n return v.enum(['development', 'production', 'test'], strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToProcessExits` validator that returns a Zod schema with\r\n * an optional stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToProcessExits\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToProcessExits` option.\r\n */\r\n listenToProcessExits(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `noLogo` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function noLogo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `noLogo`\r\n * option.\r\n */\r\n noLogo(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `hardResetPage` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function hardResetPage\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `hardResetPage` option.\r\n */\r\n hardResetPage(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `browserShellMode` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function browserShellMode\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `browserShellMode` option.\r\n */\r\n browserShellMode(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `validation` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function validation\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `validation`\r\n * option.\r\n */\r\n validation(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `enableDebug` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function enableDebug\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `enableDebug`\r\n * option.\r\n */\r\n enableDebug(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `headless` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function headless\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `headless`\r\n * option.\r\n */\r\n headless(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `devtools` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function devtools\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `devtools`\r\n * option.\r\n */\r\n devtools(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `listenToConsole` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function listenToConsole\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `listenToConsole` option.\r\n */\r\n listenToConsole(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `dumpio` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `boolean` validator.\r\n *\r\n * @function dumpio\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `dumpio`\r\n * option.\r\n */\r\n dumpio(strictCheck) {\r\n return v.boolean(strictCheck);\r\n },\r\n\r\n /**\r\n * The `slowMo` validator that returns a Zod schema with an optional stricter\r\n * check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function slowMo\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `slowMo`\r\n * option.\r\n */\r\n slowMo(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `debuggingPort` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `nonNegativeNum`\r\n * validator.\r\n *\r\n * @function debuggingPort\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating\r\n * the `debuggingPort` option.\r\n */\r\n debuggingPort(strictCheck) {\r\n return v.nonNegativeNum(strictCheck);\r\n },\r\n\r\n /**\r\n * The `requestId` validator that returns a Zod schema with an optional\r\n * stricter check based on the `strictCheck` parameter.\r\n *\r\n * The validation schema ensures the same work as the `string` validator.\r\n * Additionally, it must be a stringified UUID or can be null.\r\n *\r\n * @function requestId\r\n *\r\n * @param {boolean} strictCheck - Determines if stricter validation should\r\n * be applied.\r\n *\r\n * @returns {z.ZodSchema} A Zod schema object for validating the `requestId`\r\n * option.\r\n */\r\n requestId() {\r\n return z\r\n .string()\r\n .uuid({ message: 'The value must be a stringified UUID' })\r\n .nullable();\r\n }\r\n};\r\n\r\n// Schema for the puppeteer section of options\r\nconst PuppeteerSchema = (strictCheck) =>\r\n z\r\n .object({\r\n args: validators.args(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the highcharts section of options\r\nconst HighchartsSchema = (strictCheck) =>\r\n z\r\n .object({\r\n version: validators.version(strictCheck),\r\n cdnUrl: validators.cdnUrl(strictCheck),\r\n forceFetch: validators.forceFetch(strictCheck),\r\n cachePath: validators.cachePath(strictCheck),\r\n coreScripts: validators.coreScripts(strictCheck),\r\n moduleScripts: validators.moduleScripts(strictCheck),\r\n indicatorScripts: validators.indicatorScripts(strictCheck),\r\n customScripts: validators.customScripts(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the export section of options\r\nconst ExportSchema = (strictCheck) =>\r\n z\r\n .object({\r\n infile: validators.infile(strictCheck),\r\n instr: validators.instr(),\r\n options: validators.options(),\r\n svg: validators.svg(),\r\n outfile: validators.outfile(strictCheck),\r\n type: validators.type(strictCheck),\r\n constr: validators.constr(strictCheck),\r\n b64: validators.b64(strictCheck),\r\n noDownload: validators.noDownload(strictCheck),\r\n defaultHeight: validators.defaultHeight(strictCheck),\r\n defaultWidth: validators.defaultWidth(strictCheck),\r\n defaultScale: validators.defaultScale(strictCheck),\r\n height: validators.height(strictCheck),\r\n width: validators.width(strictCheck),\r\n scale: validators.scale(strictCheck),\r\n globalOptions: validators.globalOptions(),\r\n themeOptions: validators.themeOptions(),\r\n batch: validators.batch(false),\r\n rasterizationTimeout: validators.rasterizationTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the customLogic section of options\r\nconst CustomLogicSchema = (strictCheck) =>\r\n z\r\n .object({\r\n allowCodeExecution: validators.allowCodeExecution(strictCheck),\r\n allowFileResources: validators.allowFileResources(strictCheck),\r\n customCode: validators.customCode(false),\r\n callback: validators.callback(false),\r\n resources: validators.resources(strictCheck),\r\n loadConfig: validators.loadConfig(false),\r\n createConfig: validators.createConfig(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.proxy section of options\r\nconst ProxySchema = (strictCheck) =>\r\n z\r\n .object({\r\n host: validators.proxyHost(false),\r\n port: validators.proxyPort(strictCheck),\r\n timeout: validators.proxyTimeout(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.rateLimiting section of options\r\nconst RateLimitingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableRateLimiting(strictCheck),\r\n maxRequests: validators.maxRequests(strictCheck),\r\n window: validators.window(strictCheck),\r\n delay: validators.delay(strictCheck),\r\n trustProxy: validators.trustProxy(strictCheck),\r\n skipKey: validators.skipKey(false),\r\n skipToken: validators.skipToken(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server.ssl section of options\r\nconst SslSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableSsl(strictCheck),\r\n force: validators.sslForce(strictCheck),\r\n port: validators.sslPort(strictCheck),\r\n certPath: validators.sslCertPath(false)\r\n })\r\n .partial();\r\n\r\n// Schema for the server section of options\r\nconst ServerSchema = (strictCheck) =>\r\n z.object({\r\n enable: validators.enableServer(strictCheck).optional(),\r\n host: validators.host(strictCheck).optional(),\r\n port: validators.port(strictCheck).optional(),\r\n uploadLimit: validators.uploadLimit(strictCheck).optional(),\r\n benchmarking: validators.serverBenchmarking(strictCheck).optional(),\r\n proxy: ProxySchema(strictCheck).optional(),\r\n rateLimiting: RateLimitingSchema(strictCheck).optional(),\r\n ssl: SslSchema(strictCheck).optional()\r\n });\r\n\r\n// Schema for the pool section of options\r\nconst PoolSchema = (strictCheck) =>\r\n z\r\n .object({\r\n minWorkers: validators.minWorkers(strictCheck),\r\n maxWorkers: validators.maxWorkers(strictCheck),\r\n workLimit: validators.workLimit(strictCheck),\r\n acquireTimeout: validators.acquireTimeout(strictCheck),\r\n createTimeout: validators.createTimeout(strictCheck),\r\n destroyTimeout: validators.destroyTimeout(strictCheck),\r\n idleTimeout: validators.idleTimeout(strictCheck),\r\n createRetryInterval: validators.createRetryInterval(strictCheck),\r\n reaperInterval: validators.reaperInterval(strictCheck),\r\n benchmarking: validators.poolBenchmarking(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the logging section of options\r\nconst LoggingSchema = (strictCheck) =>\r\n z\r\n .object({\r\n level: validators.logLevel(strictCheck),\r\n file: validators.logFile(strictCheck),\r\n dest: validators.logDest(strictCheck),\r\n toConsole: validators.logToConsole(strictCheck),\r\n toFile: validators.logToFile(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the ui section of options\r\nconst UiSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableUi(strictCheck),\r\n route: validators.uiRoute(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the other section of options\r\nconst OtherSchema = (strictCheck) =>\r\n z\r\n .object({\r\n nodeEnv: validators.nodeEnv(strictCheck),\r\n listenToProcessExits: validators.listenToProcessExits(strictCheck),\r\n noLogo: validators.noLogo(strictCheck),\r\n hardResetPage: validators.hardResetPage(strictCheck),\r\n browserShellMode: validators.browserShellMode(strictCheck),\r\n validation: validators.validation(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Schema for the debug section of options\r\nconst DebugSchema = (strictCheck) =>\r\n z\r\n .object({\r\n enable: validators.enableDebug(strictCheck),\r\n headless: validators.headless(strictCheck),\r\n devtools: validators.devtools(strictCheck),\r\n listenToConsole: validators.listenToConsole(strictCheck),\r\n dumpio: validators.dumpio(strictCheck),\r\n slowMo: validators.slowMo(strictCheck),\r\n debuggingPort: validators.debuggingPort(strictCheck)\r\n })\r\n .partial();\r\n\r\n// Strict schema for the config\r\nexport const StrictConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(true),\r\n highcharts: HighchartsSchema(true),\r\n export: ExportSchema(true),\r\n customLogic: CustomLogicSchema(true),\r\n server: ServerSchema(true),\r\n pool: PoolSchema(true),\r\n logging: LoggingSchema(true),\r\n ui: UiSchema(true),\r\n other: OtherSchema(true),\r\n debug: DebugSchema(true)\r\n});\r\n\r\n// Loose schema for the config\r\nexport const LooseConfigSchema = z.object({\r\n requestId: validators.requestId(),\r\n puppeteer: PuppeteerSchema(false),\r\n highcharts: HighchartsSchema(false),\r\n export: ExportSchema(false),\r\n customLogic: CustomLogicSchema(false),\r\n server: ServerSchema(false),\r\n pool: PoolSchema(false),\r\n logging: LoggingSchema(false),\r\n ui: UiSchema(false),\r\n other: OtherSchema(false),\r\n debug: DebugSchema(false)\r\n});\r\n\r\n// Schema for the environment variables config\r\nexport const EnvSchema = z.object({\r\n // puppeteer\r\n PUPPETEER_ARGS: validators.args(false),\r\n\r\n // highcharts\r\n HIGHCHARTS_VERSION: validators.version(false),\r\n HIGHCHARTS_CDN_URL: validators.cdnUrl(false),\r\n HIGHCHARTS_FORCE_FETCH: validators.forceFetch(false),\r\n HIGHCHARTS_CACHE_PATH: validators.cachePath(false),\r\n HIGHCHARTS_ADMIN_TOKEN: validators.adminToken(false),\r\n HIGHCHARTS_CORE_SCRIPTS: validators.coreScripts(false),\r\n HIGHCHARTS_MODULE_SCRIPTS: validators.moduleScripts(false),\r\n HIGHCHARTS_INDICATOR_SCRIPTS: validators.indicatorScripts(false),\r\n HIGHCHARTS_CUSTOM_SCRIPTS: validators.customScripts(false),\r\n\r\n // export\r\n EXPORT_INFILE: validators.infile(false),\r\n EXPORT_INSTR: validators.instr(),\r\n EXPORT_OPTIONS: validators.options(),\r\n EXPORT_SVG: validators.svg(),\r\n EXPORT_BATCH: validators.batch(false),\r\n EXPORT_OUTFILE: validators.outfile(false),\r\n EXPORT_TYPE: validators.type(false),\r\n EXPORT_CONSTR: validators.constr(false),\r\n EXPORT_B64: validators.b64(false),\r\n EXPORT_NO_DOWNLOAD: validators.noDownload(false),\r\n EXPORT_HEIGHT: validators.height(false),\r\n EXPORT_WIDTH: validators.width(false),\r\n EXPORT_SCALE: validators.scale(false),\r\n EXPORT_DEFAULT_HEIGHT: validators.defaultHeight(false),\r\n EXPORT_DEFAULT_WIDTH: validators.defaultWidth(false),\r\n EXPORT_DEFAULT_SCALE: validators.defaultScale(false),\r\n EXPORT_GLOBAL_OPTIONS: validators.globalOptions(),\r\n EXPORT_THEME_OPTIONS: validators.themeOptions(),\r\n EXPORT_RASTERIZATION_TIMEOUT: validators.rasterizationTimeout(false),\r\n\r\n // custom\r\n CUSTOM_LOGIC_ALLOW_CODE_EXECUTION: validators.allowCodeExecution(false),\r\n CUSTOM_LOGIC_ALLOW_FILE_RESOURCES: validators.allowFileResources(false),\r\n CUSTOM_LOGIC_CUSTOM_CODE: validators.customCode(false),\r\n CUSTOM_LOGIC_CALLBACK: validators.callback(false),\r\n CUSTOM_LOGIC_RESOURCES: validators.resources(false),\r\n CUSTOM_LOGIC_LOAD_CONFIG: validators.loadConfig(false),\r\n CUSTOM_LOGIC_CREATE_CONFIG: validators.createConfig(false),\r\n\r\n // server\r\n SERVER_ENABLE: validators.enableServer(false),\r\n SERVER_HOST: validators.host(false),\r\n SERVER_PORT: validators.port(false),\r\n SERVER_UPLOAD_LIMIT: validators.uploadLimit(false),\r\n SERVER_BENCHMARKING: validators.serverBenchmarking(false),\r\n\r\n // server proxy\r\n SERVER_PROXY_HOST: validators.proxyHost(false),\r\n SERVER_PROXY_PORT: validators.proxyPort(false),\r\n SERVER_PROXY_TIMEOUT: validators.proxyTimeout(false),\r\n\r\n // server rate limiting\r\n SERVER_RATE_LIMITING_ENABLE: validators.enableRateLimiting(false),\r\n SERVER_RATE_LIMITING_MAX_REQUESTS: validators.maxRequests(false),\r\n SERVER_RATE_LIMITING_WINDOW: validators.window(false),\r\n SERVER_RATE_LIMITING_DELAY: validators.delay(false),\r\n SERVER_RATE_LIMITING_TRUST_PROXY: validators.trustProxy(false),\r\n SERVER_RATE_LIMITING_SKIP_KEY: validators.skipKey(false),\r\n SERVER_RATE_LIMITING_SKIP_TOKEN: validators.skipToken(false),\r\n\r\n // server ssl\r\n SERVER_SSL_ENABLE: validators.enableSsl(false),\r\n SERVER_SSL_FORCE: validators.sslForce(false),\r\n SERVER_SSL_PORT: validators.sslPort(false),\r\n SERVER_SSL_CERT_PATH: validators.sslCertPath(false),\r\n\r\n // pool\r\n POOL_MIN_WORKERS: validators.minWorkers(false),\r\n POOL_MAX_WORKERS: validators.maxWorkers(false),\r\n POOL_WORK_LIMIT: validators.workLimit(false),\r\n POOL_ACQUIRE_TIMEOUT: validators.acquireTimeout(false),\r\n POOL_CREATE_TIMEOUT: validators.createTimeout(false),\r\n POOL_DESTROY_TIMEOUT: validators.destroyTimeout(false),\r\n POOL_IDLE_TIMEOUT: validators.idleTimeout(false),\r\n POOL_CREATE_RETRY_INTERVAL: validators.createRetryInterval(false),\r\n POOL_REAPER_INTERVAL: validators.reaperInterval(false),\r\n POOL_BENCHMARKING: validators.poolBenchmarking(false),\r\n\r\n // logging\r\n LOGGING_LEVEL: validators.logLevel(false),\r\n LOGGING_FILE: validators.logFile(false),\r\n LOGGING_DEST: validators.logDest(false),\r\n LOGGING_TO_CONSOLE: validators.logToConsole(false),\r\n LOGGING_TO_FILE: validators.logToFile(false),\r\n\r\n // ui\r\n UI_ENABLE: validators.enableUi(false),\r\n UI_ROUTE: validators.uiRoute(false),\r\n\r\n // other\r\n OTHER_NODE_ENV: validators.nodeEnv(false),\r\n OTHER_LISTEN_TO_PROCESS_EXITS: validators.listenToProcessExits(false),\r\n OTHER_NO_LOGO: validators.noLogo(false),\r\n OTHER_HARD_RESET_PAGE: validators.hardResetPage(false),\r\n OTHER_BROWSER_SHELL_MODE: validators.browserShellMode(false),\r\n OTHER_VALIDATION: validators.validation(false),\r\n\r\n // debugger\r\n DEBUG_ENABLE: validators.enableDebug(false),\r\n DEBUG_HEADLESS: validators.headless(false),\r\n DEBUG_DEVTOOLS: validators.devtools(false),\r\n DEBUG_LISTEN_TO_CONSOLE: validators.listenToConsole(false),\r\n DEBUG_DUMPIO: validators.dumpio(false),\r\n DEBUG_SLOW_MO: validators.slowMo(false),\r\n DEBUG_DEBUGGING_PORT: validators.debuggingPort(false)\r\n});\r\n\r\n/**\r\n * Validates the environment variables options using the EnvSchema.\r\n *\r\n * @param {Object} process.env - The configuration options from environment\r\n * variables file to validate.\r\n *\r\n * @returns {Object} The parsed and validated environment variables.\r\n */\r\nexport const envs = EnvSchema.partial().parse(process.env);\r\n\r\n/**\r\n * Validates the configuration options using the `StrictConfigSchema`.\r\n *\r\n * @function strictValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function strictValidate(configOptions) {\r\n return StrictConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Validates the configuration options using the `LooseConfigSchema`.\r\n *\r\n * @function looseValidate\r\n *\r\n * @param {Object} configOptions - The configuration options to validate.\r\n *\r\n * @returns {Object} The parsed and validated configuration options.\r\n */\r\nexport function looseValidate(configOptions) {\r\n return LooseConfigSchema.partial().parse(configOptions);\r\n}\r\n\r\n/**\r\n * Custom error mapping function for Zod schema validation.\r\n *\r\n * This function customizes the error messages produced by Zod schema\r\n * validation, providing more specific and user-friendly feedback based on the\r\n * issue type and context.\r\n *\r\n * The function modifies the error messages as follows:\r\n *\r\n * - For missing required values (undefined), it returns a message indicating\r\n * that no value was provided for the specific property.\r\n *\r\n * - For custom validation errors, if a custom error message is provided in the\r\n * issue parameters, it includes this message along with the invalid data\r\n * received.\r\n *\r\n * - For all other errors, it appends property-specific information to the\r\n * default error message provided by Zod.\r\n *\r\n * @function _customErrorMap\r\n *\r\n * @param {z.ZodIssue} issue - The issue object representing the validation\r\n * error.\r\n * @param {Object} context - The context object providing additional information\r\n * about the validation error.\r\n *\r\n * @returns {Object} An object containing the customized error message.\r\n */\r\nfunction _customErrorMap(issue, context) {\r\n // Get the chain of properties which error directly refers to\r\n const propertyName = issue.path.join('.');\r\n\r\n // Create the first part of the message about the property information\r\n const propertyInfo = `Invalid value for the ${propertyName}`;\r\n\r\n // Modified message for the invalid type\r\n if (issue.code === z.ZodIssueCode.invalid_type) {\r\n // Modified message for the required values\r\n if (issue.received === z.ZodParsedType.undefined) {\r\n return {\r\n message: `${propertyInfo} - No value was provided.`\r\n };\r\n }\r\n\r\n // Modified message for the specific invalid type when values exist\r\n return {\r\n message: `${propertyInfo} - Invalid type. ${context.defaultError}.`\r\n };\r\n }\r\n\r\n // Modified message for the custom validation\r\n if (issue.code === z.ZodIssueCode.custom) {\r\n // If the custom message for error exist, include it\r\n if (issue.params?.errorMessage) {\r\n return {\r\n message: `${propertyInfo} - ${issue.params?.errorMessage}, received '${context.data}'.`\r\n };\r\n }\r\n }\r\n\r\n // Modified message for the invalid union error\r\n if (issue.code === z.ZodIssueCode.invalid_union) {\r\n // Create the first part of the message about the multiple errors\r\n let message = `Multiple errors occurred for the ${propertyName}:\\n`;\r\n\r\n // Cycle through all errors and create a correct message\r\n issue.unionErrors.forEach((value) => {\r\n const index = value.issues[0].message.indexOf('-');\r\n message +=\r\n index !== -1\r\n ? `${value.issues[0].message}\\n`.substring(index)\r\n : `${value.issues[0].message}\\n`;\r\n });\r\n\r\n // Return the final message for the invalid union error\r\n return {\r\n message\r\n };\r\n }\r\n\r\n // Return the default error message, extended by the info about the property\r\n return {\r\n message: `${propertyInfo} - ${context.defaultError}.`\r\n };\r\n}\r\n\r\nexport default {\r\n validators,\r\n StrictConfigSchema,\r\n LooseConfigSchema,\r\n EnvSchema,\r\n envs,\r\n strictValidate,\r\n looseValidate\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * A custom error class for handling export-related errors. Extends the native\r\n * `Error` class to include additional properties like status code and stack\r\n * trace details.\r\n */\r\nclass ExportError extends Error {\r\n /**\r\n * Creates an instance of the `ExportError`.\r\n *\r\n * @param {string} message - The error message to be displayed.\r\n * @param {number} statusCode - Optional HTTP status code associated\r\n * with the error (e.g., 400, 500).\r\n */\r\n constructor(message, statusCode) {\r\n super();\r\n\r\n // Set the `message` and `stackMessage` with provided message\r\n this.message = message;\r\n this.stackMessage = message;\r\n\r\n // Set the `statusCode` if provided\r\n if (statusCode) {\r\n this.statusCode = statusCode;\r\n }\r\n }\r\n\r\n /**\r\n * Sets additional error details based on an existing error object.\r\n *\r\n * @param {Error} error - An error object containing details to populate\r\n * the `ExportError` instance.\r\n *\r\n * @returns {ExportError} The updated instance of the `ExportError` class.\r\n */\r\n setError(error) {\r\n // Save the provided error\r\n this.error = error;\r\n\r\n // Set the error's name if present\r\n if (error.name) {\r\n this.name = error.name;\r\n }\r\n\r\n // Set the error's status code if present\r\n if (error.statusCode) {\r\n this.statusCode = error.statusCode;\r\n }\r\n\r\n // Set the error's stack and stack's message if present\r\n if (error.stack) {\r\n this.stackMessage = error.message;\r\n this.stack = error.stack;\r\n }\r\n\r\n // Return updated `ExportError` instance\r\n return this;\r\n }\r\n}\r\n\r\nexport default ExportError;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module manages configuration for the Highcharts Export Server\r\n * by loading and merging options from multiple sources, such as the default\r\n * settings, environment variables, user-provided options, and command-line\r\n * arguments. Ensures the global options are up-to-date with the highest\r\n * priority values. Provides functions for accessing and updating configuration.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\n\r\nimport { log, logWithStack, logZodIssues } from './logger.js';\r\nimport { deepCopy, getAbsolutePath, isObject } from './utils.js';\r\nimport {\r\n envs,\r\n looseValidate,\r\n strictValidate,\r\n validators\r\n} from './validation.js';\r\n\r\nimport defaultConfig from './schemas/config.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Sets the global options with initial values from the default config\r\nconst globalOptions = _initOptions(defaultConfig);\r\n\r\n// Properties nesting level of all options\r\nconst nestedProps = _createNestedProps(defaultConfig);\r\n\r\n// Properties names that should not be recursively merged\r\nconst absoluteProps = _createAbsoluteProps(defaultConfig);\r\n\r\n/**\r\n * Retrieves a copy of the global options object or an original global options\r\n * object, based on the `getCopy` flag.\r\n *\r\n * @function getOptions\r\n *\r\n * @param {boolean} [getCopy=true] - Specifies whether to return a copied\r\n * object of the global options (`true`) or a reference to the global options\r\n * object (`false`). The default value is `true`.\r\n *\r\n * @returns {Object} A copy of the global options object, or a reference\r\n * to the global options object.\r\n */\r\nexport function getOptions(getCopy = true) {\r\n // Return a copy or an original global options object\r\n return getCopy ? deepCopy(globalOptions) : globalOptions;\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object or a copy of the global options\r\n * object, based on the `getCopy` flag. The `newOptions` object can be\r\n * strictly validated depending on the `strictCheck` flag.\r\n *\r\n * @function updateOptions\r\n *\r\n * @param {Object} newOptions - An object containing the new options to be\r\n * merged into the global options.\r\n * @param {boolean} [getCopy=false] - Determines whether to merge the new\r\n * options into a copy of the global options object (`true`) or directly into\r\n * the global options object (`false`). The default value is `false`.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The updated options object, either the modified global\r\n * options or a modified copy, based on the value of `getCopy`.\r\n */\r\nexport function updateOptions(newOptions, getCopy = false, strictCheck = true) {\r\n // Merge new options to the global options or its copy and return the result\r\n return _mergeOptions(\r\n // First, get the options\r\n getOptions(getCopy),\r\n // Next, validate the new options\r\n validateOptions(newOptions, strictCheck)\r\n );\r\n}\r\n\r\n/**\r\n * Updates and returns the global options object with values provided through\r\n * the CLI, keeping the principle of options load priority. The function accepts\r\n * a `cliArgs` array containing arguments from the CLI, which will be validated\r\n * and applied if provided.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from the command line interface (CLI).\r\n * 2. Values from a custom JSON file (loaded by the `--loadConfig` option).\r\n *\r\n * @function setCliOptions\r\n *\r\n * @param {Array} cliArgs - An array of command line arguments used\r\n * for additional configuration.\r\n *\r\n * @returns {Object} The updated global options object, reflecting the merged\r\n * configuration from sources provided through the CLI.\r\n */\r\nexport function setCliOptions(cliArgs) {\r\n // Only for the CLI usage\r\n if (cliArgs && Array.isArray(cliArgs) && cliArgs.length) {\r\n try {\r\n // Get options from the custom JSON loaded via the `--loadConfig`\r\n const configOptions = _loadConfigFile(cliArgs);\r\n\r\n // Update global options with validated values from the `configOptions`\r\n updateOptions(configOptions);\r\n } catch (error) {\r\n log(2, '[validation] No options added from the `--loadConfig` option.');\r\n }\r\n\r\n try {\r\n // Get options from the CLI\r\n const cliOptions = _pairArgumentValue(cliArgs);\r\n\r\n // Update global options with validated values from the `cliOptions`\r\n updateOptions(cliOptions, false, false);\r\n } catch (error) {\r\n log(2, '[validation] No options added from the CLI arguments.');\r\n }\r\n }\r\n\r\n // Return reference to the global options\r\n return getOptions(false);\r\n}\r\n\r\n/**\r\n * Maps old-structured configuration options (PhantomJS-based) to a new format\r\n * (Puppeteer-based). This function converts flat, old-structured options into\r\n * a new, nested configuration format based on a predefined mapping provided\r\n * in the `nestedProps` object. The new format is used for Puppeteer, while\r\n * the old format was used for PhantomJS.\r\n *\r\n * @function mapToNewOptions\r\n *\r\n * @param {Object} oldOptions - The old, flat configuration options\r\n * to be converted.\r\n *\r\n * @returns {Object} A new object containing options structured according\r\n * to the mapping defined in the `nestedProps` object or an empty object\r\n * if the provided `oldOptions` is not a correct object.\r\n */\r\nexport function mapToNewOptions(oldOptions) {\r\n // An object for the new structured options\r\n const newOptions = {};\r\n\r\n // Check if provided value is a correct object\r\n if (isObject(oldOptions)) {\r\n // Iterate over each key-value pair in the old-structured options\r\n for (const [key, value] of Object.entries(oldOptions)) {\r\n // If there is a nested mapping, split it into a properties chain\r\n const propertiesChain = nestedProps[key]\r\n ? nestedProps[key].split('.')\r\n : [];\r\n\r\n // If it is the last property in the chain, assign the value, otherwise,\r\n // create or reuse the nested object\r\n propertiesChain.reduce(\r\n (obj, prop, index) =>\r\n (obj[prop] =\r\n propertiesChain.length - 1 === index ? value : obj[prop] || {}),\r\n newOptions\r\n );\r\n }\r\n } else {\r\n log(\r\n 2,\r\n '[config] No correct object with options was provided. Returning an empty object.'\r\n );\r\n }\r\n\r\n // Return the new, structured options object\r\n return newOptions;\r\n}\r\n\r\n/**\r\n * Validates a specified option using the corresponding validator from the\r\n * configuration object. Returns the original option if the validation\r\n * is disabled globally.\r\n *\r\n * @function validateOption\r\n *\r\n * @param {string} name - The name of the option to validate.\r\n * @param {any} configOption - The value of the option to validate.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {any} The parsed and validated value of the option.\r\n */\r\nexport function validateOption(name, configOption, strictCheck = true) {\r\n // Return the original option if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOption;\r\n }\r\n\r\n try {\r\n // Return validated option\r\n return validators[name](strictCheck).parse(configOption);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(\r\n 1,\r\n error.issues,\r\n `[validation] The ${name} option validation error`\r\n );\r\n\r\n // Throw validation error\r\n throw new ExportError(\r\n `[validation] The ${name} option validation error`,\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Validates the provided configuration options for the exporting process.\r\n * Returns the original option if the validation is disabled globally.\r\n *\r\n * @function validateOptions\r\n *\r\n * @param {Object} configOptions - The configuration options to be validated.\r\n * @param {boolean} [strictCheck=true] - Determines if stricter validation\r\n * should be applied. The default value is `true`.\r\n *\r\n * @returns {Object} The parsed and validated configuration options object.\r\n */\r\nexport function validateOptions(configOptions, strictCheck = true) {\r\n // Return the original config if the validation is disabled\r\n if (!getOptions().other.validation) {\r\n return configOptions;\r\n }\r\n\r\n try {\r\n // Return validated options\r\n return strictCheck\r\n ? strictValidate(configOptions)\r\n : looseValidate(configOptions);\r\n } catch (error) {\r\n // Log Zod issues\r\n logZodIssues(1, error.issues, '[validation] Options validation error');\r\n\r\n // Throw validation error\r\n throw new ExportError('[validation] Options validation error', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Validates, parses, and checks if the provided config is allowed set\r\n * of options.\r\n *\r\n * @function isAllowedConfig\r\n *\r\n * @param {unknown} config - The config to be validated and parsed as a set\r\n * of options. Must be either an object or a string.\r\n * @param {boolean} [toString=false] - Whether to return a stringified version\r\n * of the parsed config. The default value is `false`.\r\n * @param {boolean} [allowFunctions=false] - Whether to allow functions\r\n * in the parsed config. If `true`, functions are preserved. Otherwise, when\r\n * a function is found, `null` is returned. The default value is `false`.\r\n *\r\n * @returns {(Object|string|null)} Returns a parsed set of options object,\r\n * a stringified set of options object if the `toString` is `true`, and `null`\r\n * if the config is not a valid set of options or parsing fails.\r\n */\r\nexport function isAllowedConfig(\r\n config,\r\n toString = false,\r\n allowFunctions = false\r\n) {\r\n try {\r\n // Accept only objects and strings\r\n if (!isObject(config) && typeof config !== 'string') {\r\n // Return `null` if any other type\r\n return null;\r\n }\r\n\r\n // Get the object representation of the original config\r\n const objectConfig =\r\n typeof config === 'string'\r\n ? allowFunctions\r\n ? eval(`(${config})`)\r\n : JSON.parse(config)\r\n : config;\r\n\r\n // Preserve or remove potential functions based on the `allowFunctions` flag\r\n const stringifiedOptions = _optionsStringify(\r\n objectConfig,\r\n allowFunctions,\r\n false\r\n );\r\n\r\n // Parse the config to check if it is valid set of options\r\n const parsedOptions = allowFunctions\r\n ? JSON.parse(\r\n _optionsStringify(objectConfig, allowFunctions, true),\r\n (_, value) =>\r\n typeof value === 'string' && value.startsWith('function')\r\n ? eval(`(${value})`)\r\n : value\r\n )\r\n : JSON.parse(stringifiedOptions);\r\n\r\n // Return stringified or object options based on the `toString` flag\r\n return toString ? stringifiedOptions : parsedOptions;\r\n } catch (error) {\r\n // Return `null` if parsing fails\r\n return null;\r\n }\r\n}\r\n\r\n/**\r\n * Initializes and returns the global options object based on the provided\r\n * configuration, setting values from nested properties recursively.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. Values from environment variables (specified in the `.env` file).\r\n * 2. Values from the `./lib/schemas/config.js` file (defaults).\r\n *\r\n * @function _initOptions\r\n *\r\n * @param {Object} config - The configuration object used for initializing\r\n * the global options. It should include nested properties with a `value`\r\n * and an `envLink` for linking to environment variables.\r\n *\r\n * @returns {Object} The initialized global options object, populated with\r\n * values based on the provided configuration and the established priority\r\n * order.\r\n */\r\nfunction _initOptions(config) {\r\n // Init the object for options\r\n const options = {};\r\n\r\n // Start initializing the `options` object recursively\r\n for (const [name, item] of Object.entries(config)) {\r\n if (Object.prototype.hasOwnProperty.call(item, 'value')) {\r\n // Set the correct value based on the established priority order\r\n if (envs[item.envLink] !== undefined && envs[item.envLink] !== null) {\r\n // The environment variables value\r\n options[name] = envs[item.envLink];\r\n } else {\r\n // The value from the config file\r\n options[name] = item.value;\r\n }\r\n } else {\r\n // Create a category of options in the `options` object\r\n options[name] = _initOptions(item);\r\n }\r\n }\r\n\r\n // Return the created `options` object\r\n return options;\r\n}\r\n\r\n/**\r\n * Recursively merges two sets of configuration options, taking into account\r\n * properties specified in the `absoluteProps` array that require absolute\r\n * merging. The `originalOptions` object will be extended with options from\r\n * the `newOptions` object.\r\n *\r\n * @function _mergeOptions\r\n *\r\n * @param {Object} originalOptions - The original configuration options object\r\n * to be extended.\r\n * @param {Object} newOptions - The new configuration options object to merge.\r\n *\r\n * @returns {Object} The extended `originalOptions` object.\r\n */\r\nfunction _mergeOptions(originalOptions, newOptions) {\r\n // Check if the `originalOptions` and `newOptions` are correct objects\r\n if (isObject(originalOptions) && isObject(newOptions)) {\r\n for (const [key, value] of Object.entries(newOptions)) {\r\n originalOptions[key] =\r\n isObject(value) &&\r\n !absoluteProps.includes(key) &&\r\n originalOptions[key] !== undefined\r\n ? _mergeOptions(originalOptions[key], value)\r\n : value !== undefined\r\n ? value\r\n : originalOptions[key] || null;\r\n }\r\n }\r\n\r\n // Return the original (modified or not) options\r\n return originalOptions;\r\n}\r\n\r\n/**\r\n * Converts the provided options object to a JSON string with the option\r\n * to preserve functions. In order for a function to be preserved, it needs\r\n * to follow the format `function (...) {...}`. Such a function can also\r\n * be stringified.\r\n *\r\n * @function _optionsStringify\r\n *\r\n * @param {Object} options - The options object to be converted to a string.\r\n * @param {boolean} allowFunctions - If set to `true`, functions are preserved\r\n * in the output. Otherwise an error is thrown.\r\n * @param {boolean} stringifyFunctions - If set to `true`, functions are saved\r\n * as strings. The `allowFunctions` must be set to `true` as well for this\r\n * to take an effect.\r\n *\r\n * @returns {string} The JSON-formatted string representing the options.\r\n *\r\n * @throws {Error} Throws an `Error` when functions are not allowed but are\r\n * found in provided options object.\r\n */\r\nfunction _optionsStringify(options, allowFunctions, stringifyFunctions) {\r\n const replacerCallback = (_, value) => {\r\n // Trim string values\r\n if (typeof value === 'string') {\r\n value = value.trim();\r\n }\r\n\r\n // If `value` is a function or stringified function\r\n if (\r\n typeof value === 'function' ||\r\n (typeof value === 'string' &&\r\n value.startsWith('function') &&\r\n value.endsWith('}'))\r\n ) {\r\n // If the `allowFunctions` is set to `true`, preserve functions\r\n if (allowFunctions) {\r\n // Based on the `stringifyFunctions` options, set function values\r\n return stringifyFunctions\r\n ? // As stringified functions\r\n `\"EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN\"`\r\n : // As functions\r\n `EXP_FUN${(value + '').replaceAll(/\\s+/g, ' ')}EXP_FUN`;\r\n } else {\r\n // Throw an error otherwise\r\n throw new Error();\r\n }\r\n }\r\n\r\n // In all other cases, simply return the value\r\n return value;\r\n };\r\n\r\n // Stringify options and if required, replace special functions marks\r\n return JSON.stringify(options, replacerCallback).replaceAll(\r\n stringifyFunctions ? /\\\\\"EXP_FUN|EXP_FUN\\\\\"/g : /\"EXP_FUN|EXP_FUN\"/g,\r\n ''\r\n );\r\n}\r\n\r\n/**\r\n * Loads additional configuration from a specified file provided via\r\n * the `--loadConfig` option in the command-line arguments.\r\n *\r\n * @function _loadConfigFile\r\n *\r\n * @param {Array} cliArgs - Command-line arguments to search\r\n * for the `--loadConfig` option and the corresponding file path.\r\n *\r\n * @returns {Object} The additional configuration loaded from the specified\r\n * file, or an empty object if the file is not found, invalid, or an error\r\n * occurs.\r\n */\r\nfunction _loadConfigFile(cliArgs) {\r\n // Get the allow flags for the custom logic check\r\n const { allowCodeExecution, allowFileResources } = getOptions().customLogic;\r\n\r\n // Check if the `--loadConfig` option was used\r\n const configIndex = cliArgs.findIndex(\r\n (arg) => arg.replace(/-/g, '') === 'loadConfig'\r\n );\r\n\r\n // Get the `--loadConfig` option value\r\n const configFileName = configIndex > -1 && cliArgs[configIndex + 1];\r\n\r\n // Check if the `--loadConfig` is present and has a correct value\r\n if (configFileName && allowFileResources) {\r\n try {\r\n // Load an optional custom JSON config file\r\n return isAllowedConfig(\r\n readFileSync(getAbsolutePath(configFileName), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[config] Unable to load the configuration from the ${configFileName} file.`\r\n );\r\n }\r\n }\r\n\r\n // No additional options to return\r\n return {};\r\n}\r\n\r\n/**\r\n * Parses command-line arguments and pairs each argument with its corresponding\r\n * option in the configuration. The values are structured into a nested options\r\n * object, based on predefined mappings in the `nestedProps` object.\r\n *\r\n * @function _pairArgumentValue\r\n *\r\n * @param {Array} cliArgs - An array of command-line arguments\r\n * containing options and their associated values.\r\n *\r\n * @returns {Object} An updated options object where each option from\r\n * the command-line is paired with its value, structured into nested objects\r\n * as defined.\r\n */\r\nfunction _pairArgumentValue(cliArgs) {\r\n // An empty object to collect and structurize data from the args\r\n const cliOptions = {};\r\n\r\n // Cycle through all CLI args and filter them\r\n for (let i = 0; i < cliArgs.length; i++) {\r\n const option = cliArgs[i].replace(/-/g, '');\r\n\r\n // Find the right place for property's value\r\n const propertiesChain = nestedProps[option]\r\n ? nestedProps[option].split('.')\r\n : [];\r\n\r\n // Create options object with values from CLI for later parsing and merging\r\n propertiesChain.reduce((obj, prop, index) => {\r\n if (propertiesChain.length - 1 === index) {\r\n const value = cliArgs[++i];\r\n if (!value) {\r\n log(\r\n 2,\r\n `[config] Missing value for the CLI '--${option}' argument. Using the default value.`\r\n );\r\n }\r\n obj[prop] = value || null;\r\n } else if (obj[prop] === undefined) {\r\n obj[prop] = {};\r\n }\r\n return obj[prop];\r\n }, cliOptions);\r\n }\r\n\r\n // Return parsed CLI options\r\n return cliOptions;\r\n}\r\n\r\n/**\r\n * Recursively generates a mapping of nested argument chains from a nested\r\n * config object. This function traverses a nested object and creates a mapping\r\n * where each key is an argument name (either from `cliName`, `legacyName`,\r\n * or the original key) and each value is a string representing the chain\r\n * of nested properties leading to that argument.\r\n *\r\n * @function _createNestedProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Object} [nestedProps={}] - The accumulator object for storing\r\n * the resulting arguments chains. The default value is an empty object.\r\n * @param {string} [propChain=''] - The current chain of nested properties,\r\n * used internally during recursion. The default value is an empty string.\r\n *\r\n * @returns {Object} An object mapping argument names to their corresponding\r\n * nested property chains.\r\n */\r\nfunction _createNestedProps(config, nestedProps = {}, propChain = '') {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.value === 'undefined') {\r\n // Recurse into deeper levels of nested arguments\r\n _createNestedProps(entry, nestedProps, `${propChain}.${key}`);\r\n } else {\r\n // Create the chain of nested arguments\r\n nestedProps[entry.cliName || key] = `${propChain}.${key}`.substring(1);\r\n\r\n // Support for the legacy, PhantomJS properties names\r\n if (entry.legacyName !== undefined) {\r\n nestedProps[entry.legacyName] = `${propChain}.${key}`.substring(1);\r\n }\r\n }\r\n });\r\n\r\n // Return the object with nested argument chains\r\n return nestedProps;\r\n}\r\n\r\n/**\r\n * Recursively gathers the names of properties from a configuration object that\r\n * should be treated as absolute properties. These properties have values that\r\n * are objects and do not contain further nested depth when merging an object\r\n * containing these options.\r\n *\r\n * @function _createAbsoluteProps\r\n *\r\n * @param {Object} config - The configuration object.\r\n * @param {Array} [absoluteProps=[]] - An array to collect the names\r\n * of absolute properties. The default value is an empty array.\r\n *\r\n * @returns {Array} An array containing the names of absolute\r\n * properties.\r\n */\r\nfunction _createAbsoluteProps(config, absoluteProps = []) {\r\n Object.keys(config).forEach((key) => {\r\n // Get the specific section\r\n const entry = config[key];\r\n\r\n // Check if there is still more depth to traverse\r\n if (typeof entry.types === 'undefined') {\r\n // Recurse into deeper levels\r\n _createAbsoluteProps(entry, absoluteProps);\r\n } else {\r\n // If the option can be an object, save its type in the array\r\n if (entry.types.includes('Object')) {\r\n absoluteProps.push(key);\r\n }\r\n }\r\n });\r\n\r\n // Return the array with the names of absolute properties\r\n return absoluteProps;\r\n}\r\n\r\nexport default {\r\n getOptions,\r\n updateOptions,\r\n setCliOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions,\r\n isAllowedConfig\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview HTTP utility module for fetching and posting data. Supports both\r\n * HTTP and HTTPS protocols, providing methods to make GET and POST requests\r\n * with customizable options. Includes protocol determination based on URL\r\n * and augments response objects with a 'text' property for easier data access.\r\n */\r\n\r\nimport http from 'http';\r\nimport https from 'https';\r\n\r\n/**\r\n * Sends a GET request to the specified URL using either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function get\r\n *\r\n * @param {string} url - The URL to get data from.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function get(url, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n // Decide on the protocol\r\n _getProtocolModule(url)\r\n .get(url, requestOptions, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n if (!responseData) {\r\n reject('Nothing was fetched from the URL.');\r\n }\r\n\r\n // Get the full result and resolve the request\r\n response.text = responseData;\r\n resolve(response);\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n });\r\n}\r\n\r\n/**\r\n * Sends a POST request to the specified URL with the provided JSON body using\r\n * either HTTP or HTTPS protocol.\r\n *\r\n * @async\r\n * @function post\r\n *\r\n * @param {string} url - The URL to send the POST request to.\r\n * @param {Object} [body={}] - The JSON body to include in the POST request.\r\n * The default value is an empty object.\r\n * @param {Object} [requestOptions={}] - Options for the HTTP/HTTPS request.\r\n * The default value is an empty object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the HTTP/HTTPS response\r\n * object with added 'text' property or rejecting with an error.\r\n */\r\nexport async function post(url, body = {}, requestOptions = {}) {\r\n return new Promise((resolve, reject) => {\r\n const data = JSON.stringify(body);\r\n\r\n // Set default headers and merge with `requestOptions`\r\n const options = Object.assign(\r\n {\r\n method: 'POST',\r\n headers: {\r\n 'Content-Type': 'application/json',\r\n 'Content-Length': data.length\r\n }\r\n },\r\n requestOptions\r\n );\r\n\r\n // Decide on the protocol\r\n const request = _getProtocolModule(url)\r\n .request(url, options, (response) => {\r\n let responseData = '';\r\n\r\n // A chunk of data has been received\r\n response.on('data', (chunk) => {\r\n responseData += chunk;\r\n });\r\n\r\n // The whole response has been received\r\n response.on('end', () => {\r\n try {\r\n // Get the full result and resolve the request\r\n response.text = responseData;\r\n resolve(response);\r\n } catch (error) {\r\n reject(error);\r\n }\r\n });\r\n })\r\n .on('error', (error) => {\r\n reject(error);\r\n });\r\n\r\n // Write the request body and end the request\r\n request.write(data);\r\n request.end();\r\n });\r\n}\r\n\r\n/**\r\n * Returns the HTTP or HTTPS protocol module based on the provided URL.\r\n *\r\n * @function _getProtocolModule\r\n *\r\n * @param {string} url - The URL to determine the protocol.\r\n *\r\n * @returns {Object} The HTTP or HTTPS protocol module (`http` or `https`).\r\n */\r\nfunction _getProtocolModule(url) {\r\n return url.startsWith('https') ? https : http;\r\n}\r\n\r\nexport default {\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview The cache manager is responsible for handling and managing\r\n * the Highcharts library along with its dependencies. It ensures that these\r\n * resources are stored and retrieved efficiently to optimize performance\r\n * and reduce redundant network requests. The cache is stored in the `.cache`\r\n * directory by default, which serves as a dedicated folder for keeping cached\r\n * files.\r\n */\r\n\r\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { HttpsProxyAgent } from 'https-proxy-agent';\r\n\r\nimport { getOptions, updateOptions } from './config.js';\r\nimport { get } from './fetch.js';\r\nimport { log } from './logger.js';\r\nimport { getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The initial cache template\r\nconst cache = {\r\n cdnUrl: 'https://code.highcharts.com',\r\n activeManifest: {},\r\n sources: '',\r\n hcVersion: ''\r\n};\r\n\r\n/**\r\n * Checks the cache for Highcharts dependencies, updates the cache if needed,\r\n * and loads the sources.\r\n *\r\n * @async\r\n * @function checkCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n */\r\nexport async function checkCache(highchartsOptions, serverProxyOptions) {\r\n try {\r\n let fetchedModules;\r\n\r\n // Get the cache path\r\n const cachePath = getCachePath();\r\n\r\n // Prepare paths to manifest and sources from the cache folder\r\n const manifestPath = join(cachePath, 'manifest.json');\r\n const sourcePath = join(cachePath, 'sources.js');\r\n\r\n // Create the cache destination if it doesn't exist already\r\n !existsSync(cachePath) && mkdirSync(cachePath, { recursive: true });\r\n\r\n // Fetch all the scripts either if the `manifest.json` does not exist\r\n // or if the `forceFetch` option is enabled\r\n if (!existsSync(manifestPath) || highchartsOptions.forceFetch) {\r\n log(3, '[cache] Fetching and caching Highcharts dependencies.');\r\n\r\n // The initial cache update\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n let requestUpdate = false;\r\n\r\n // Read the manifest JSON\r\n const manifest = JSON.parse(readFileSync(manifestPath), 'utf8');\r\n\r\n // Check if the modules is an array, if so, we rewrite it to a map to make\r\n // it easier to resolve modules\r\n if (manifest.modules && Array.isArray(manifest.modules)) {\r\n const moduleMap = {};\r\n manifest.modules.forEach((m) => (moduleMap[m] = 1));\r\n manifest.modules = moduleMap;\r\n }\r\n\r\n // Get the actual number of scripts to be fetched\r\n const { coreScripts, moduleScripts, indicatorScripts } =\r\n highchartsOptions;\r\n const numberOfModules =\r\n coreScripts.length + moduleScripts.length + indicatorScripts.length;\r\n\r\n // Compare the loaded highcharts config with the contents in cache.\r\n // If there are changes, fetch requested modules and products,\r\n // and bake them into a giant blob. Save the blob.\r\n if (manifest.version !== highchartsOptions.version) {\r\n // Check the Highcharts version\r\n log(\r\n 2,\r\n '[cache] A Highcharts version mismatch in the cache, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else if (\r\n Object.keys(manifest.modules || {}).length !== numberOfModules\r\n ) {\r\n // Check the number of modules\r\n log(\r\n 2,\r\n '[cache] The cache and the requested modules do not match, need to re-fetch.'\r\n );\r\n requestUpdate = true;\r\n } else {\r\n // Check each module, if anything is missing refetch everything\r\n requestUpdate = (moduleScripts || []).some((moduleName) => {\r\n if (!manifest.modules[moduleName]) {\r\n log(\r\n 2,\r\n `[cache] The ${moduleName} is missing in the cache, need to re-fetch.`\r\n );\r\n return true;\r\n }\r\n });\r\n }\r\n\r\n // Update cache if needed\r\n if (requestUpdate) {\r\n fetchedModules = await _updateCache(\r\n highchartsOptions,\r\n serverProxyOptions,\r\n sourcePath\r\n );\r\n } else {\r\n log(3, '[cache] Dependency cache is up to date, proceeding.');\r\n\r\n // Load the sources\r\n cache.sources = readFileSync(sourcePath, 'utf8');\r\n\r\n // Get current modules map\r\n fetchedModules = manifest.modules;\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = _extractHcVersion(cache.sources);\r\n }\r\n }\r\n\r\n // Finally, save the new manifest, which is basically our current config\r\n // in a slightly different format\r\n await _saveConfigToManifest(highchartsOptions.version, fetchedModules);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not configure cache and create or update the config manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Gets the version of Highcharts from the cache.\r\n *\r\n * @function getHcVersion\r\n *\r\n * @returns {string} The cached Highcharts version.\r\n */\r\nexport function getHcVersion() {\r\n return cache.hcVersion;\r\n}\r\n\r\n/**\r\n * Updates the Highcharts version in the applied configuration and checks\r\n * the cache for the scripts of a new version.\r\n *\r\n * @async\r\n * @function updateHcVersion\r\n *\r\n * @param {string} newVersion - The new Highcharts version to be applied.\r\n */\r\nexport async function updateHcVersion(newVersion) {\r\n // Update to the new version\r\n const options = updateOptions({\r\n highcharts: {\r\n version: newVersion\r\n }\r\n });\r\n\r\n // Check if cache needs to be updated\r\n await checkCache(options.highcharts, options.server.proxy);\r\n}\r\n\r\n/**\r\n * Retrieves the current cache object.\r\n *\r\n * @function getCache\r\n *\r\n * @returns {Object} The cache object containing various cached data.\r\n */\r\nexport function getCache() {\r\n return cache;\r\n}\r\n\r\n/**\r\n * Gets the cache path for Highcharts.\r\n *\r\n * @function getCachePath\r\n *\r\n * @returns {string} The absolute path to the cache directory for Highcharts.\r\n */\r\nexport function getCachePath() {\r\n return getAbsolutePath(getOptions().highcharts.cachePath, 'utf8'); // #562\r\n}\r\n\r\n/**\r\n * Saves the provided configuration and fetched modules to the cache manifest\r\n * file.\r\n *\r\n * @async\r\n * @function _saveConfigToManifest\r\n *\r\n * @param {number} version - The currently used Highcharts version.\r\n * @param {Object} [fetchedModules={}] - An object which tracks which modules\r\n * have been fetched. The default value is an empty object.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs while\r\n * writing the cache manifest.\r\n */\r\nasync function _saveConfigToManifest(version, fetchedModules = {}) {\r\n // Update cache object with the current modules\r\n cache.activeManifest = {\r\n version,\r\n modules: fetchedModules\r\n };\r\n\r\n log(3, '[cache] Writing a new manifest.');\r\n try {\r\n writeFileSync(\r\n join(getCachePath(), 'manifest.json'),\r\n JSON.stringify(cache.activeManifest),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Error writing the cache manifest.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Updates the local cache with Highcharts scripts content and information,\r\n * and used Highcharts version.\r\n *\r\n * @async\r\n * @function _updateCache\r\n *\r\n * @param {Object} highchartsOptions - The configuration object containing\r\n * `highcharts` options.\r\n * @param {Object} serverProxyOptions - The configuration object containing\r\n * `server.proxy` options.\r\n * @param {string} sourcePath - The path to the source file in the cache.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object representing\r\n * the fetched modules.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an issue updating\r\n * the local Highcharts cache.\r\n */\r\nasync function _updateCache(highchartsOptions, serverProxyOptions, sourcePath) {\r\n try {\r\n // Get Highcharts version for scripts\r\n const hcVersion =\r\n highchartsOptions.version === 'latest'\r\n ? null\r\n : `${highchartsOptions.version}`;\r\n\r\n log(\r\n 3,\r\n `[cache] Updating cache version to Highcharts: ${hcVersion || 'latest'}.`\r\n );\r\n\r\n // Get the CDN url for scripts\r\n const cdnUrl = highchartsOptions.cdnUrl || cache.cdnUrl;\r\n\r\n // Prepare options for a request\r\n const requestOptions = _configureRequest(serverProxyOptions);\r\n\r\n // An object to record which scripts are fetched\r\n const fetchedModules = {};\r\n\r\n // Join all fetched scripts and save in the manifest's sources\r\n cache.sources = (\r\n await Promise.all([\r\n // Highcharts core scripts fetch\r\n ...highchartsOptions.coreScripts.map((cs) =>\r\n _fetchScript(\r\n hcVersion ? `${cdnUrl}/${hcVersion}/${cs}` : `${cdnUrl}/${cs}`,\r\n requestOptions,\r\n fetchedModules,\r\n true\r\n )\r\n ),\r\n // Highcharts module scripts fetch\r\n ...highchartsOptions.moduleScripts.map((ms) =>\r\n _fetchScript(\r\n ms === 'map'\r\n ? hcVersion\r\n ? `${cdnUrl}/maps/${hcVersion}/modules/${ms}`\r\n : `${cdnUrl}/maps/modules/${ms}`\r\n : hcVersion\r\n ? `${cdnUrl}/${hcVersion}/modules/${ms}`\r\n : `${cdnUrl}/modules/${ms}`,\r\n requestOptions,\r\n fetchedModules\r\n )\r\n ),\r\n // Highcharts indicator scripts fetch\r\n ...highchartsOptions.indicatorScripts.map((is) =>\r\n _fetchScript(\r\n hcVersion\r\n ? `${cdnUrl}/stock/${hcVersion}/indicators/${is}`\r\n : `${cdnUrl}/stock/indicators/${is}`,\r\n requestOptions,\r\n fetchedModules\r\n )\r\n ),\r\n // Custom scripts fetch\r\n ...highchartsOptions.customScripts.map((cs) =>\r\n _fetchScript(`${cs}`, requestOptions)\r\n )\r\n ])\r\n ).join(';\\n');\r\n\r\n // Extract and save version of currently used Highcharts\r\n cache.hcVersion = _extractHcVersion(cache.sources);\r\n\r\n // Save the fetched modules into caches' source JSON\r\n writeFileSync(sourcePath, cache.sources);\r\n\r\n // Return the fetched modules\r\n return fetchedModules;\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Unable to update the local Highcharts cache.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Fetches a single script and updates the `fetchedModules` accordingly.\r\n *\r\n * @async\r\n * @function _fetchScript\r\n *\r\n * @param {string} script - A path to script to get.\r\n * @param {Object} requestOptions - Additional requests options.\r\n * @param {Object} fetchedModules - An object which tracks which Highcharts\r\n * modules have been fetched.\r\n * @param {boolean} [shouldThrowError=false] - A flag to indicate if the error\r\n * should be thrown. This should be used only for the core scripts. The default\r\n * value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to the text representation\r\n * of the fetched script.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem\r\n * with fetching the script.\r\n */\r\nasync function _fetchScript(\r\n script,\r\n requestOptions,\r\n fetchedModules,\r\n shouldThrowError = false\r\n) {\r\n // Get rid of the .js from the custom strings\r\n if (script.endsWith('.js')) {\r\n script = script.substring(0, script.length - 3);\r\n }\r\n log(4, `[cache] Fetching script - ${script}.js`);\r\n\r\n // Fetch the script\r\n const response = await get(`${script}.js`, requestOptions);\r\n\r\n // If OK, return its text representation\r\n if (response.statusCode === 200 && typeof response.text == 'string') {\r\n if (fetchedModules) {\r\n const moduleName = _extractModuleName(script);\r\n fetchedModules[moduleName] = 1;\r\n }\r\n return response.text;\r\n }\r\n\r\n // Based on the `shouldThrowError` flag, decide how to serve error message\r\n if (shouldThrowError) {\r\n throw new ExportError(\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version (status code: ${response.statusCode}).`,\r\n 404\r\n ).setError(response);\r\n } else {\r\n log(\r\n 2,\r\n `[cache] Could not fetch the ${script}.js. The script might not exist in the requested version.`\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Configures a proxy agent for outgoing HTTP requests based on the provided\r\n * `server.proxy` options. If a valid `host` and `port` are specified, it tries\r\n * to create an `HttpsProxyAgent`. If the creation fails, an `ExportError`\r\n * is thrown. If no proxy is configured, an empty object is returned.\r\n *\r\n * @function _configureRequest\r\n *\r\n * @param {Object} serverProxyOptions- The configuration object containing\r\n * `server.proxy` options.\r\n *\r\n * @returns {Object} The request options, including the proxy agent if created,\r\n * or an empty object if no proxy configuration is provided.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the proxy agent creation\r\n * fails.\r\n */\r\nfunction _configureRequest(serverProxyOptions) {\r\n // Get the `host` and `port` of the proxy\r\n const proxyHost = serverProxyOptions.host;\r\n const proxyPort = serverProxyOptions.port;\r\n\r\n // Try to create a proxy agent\r\n if (proxyHost && proxyPort) {\r\n try {\r\n // Create the agent\r\n const proxyAgent = new HttpsProxyAgent({\r\n host: proxyHost,\r\n port: proxyPort\r\n });\r\n\r\n // Add the agent to the request's options\r\n return {\r\n agent: proxyAgent,\r\n timeout: serverProxyOptions.timeout\r\n };\r\n } catch (error) {\r\n throw new ExportError(\r\n '[cache] Could not create a Proxy Agent.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n\r\n // Return an empty object when no proxy agent is created\r\n return {};\r\n}\r\n\r\n/**\r\n * Extracts Highcharts version from the cache's sources string.\r\n *\r\n * @function _extractHcVersion\r\n *\r\n * @param {Object} cacheSources - The cache sources object.\r\n *\r\n * @returns {string} The extracted Highcharts version.\r\n */\r\nfunction _extractHcVersion(cacheSources) {\r\n return cacheSources\r\n .substring(0, cacheSources.indexOf('*/'))\r\n .replace('/*', '')\r\n .replace('*/', '')\r\n .replace(/\\n/g, '')\r\n .trim();\r\n}\r\n\r\n/**\r\n * Extracts the Highcharts module name based on the `scriptPath` property.\r\n *\r\n * @function _extractModuleName\r\n *\r\n * @param {string} scriptPath - The path of the script from which the module\r\n * name will be extracted.\r\n *\r\n * @returns {string} The extracted module name.\r\n */\r\nfunction _extractModuleName(scriptPath) {\r\n return scriptPath.replace(\r\n /(.*)\\/|(.*)modules\\/|stock\\/(.*)indicators\\/|maps\\/(.*)modules\\//gi,\r\n ''\r\n );\r\n}\r\n\r\nexport default {\r\n checkCache,\r\n getHcVersion,\r\n updateHcVersion,\r\n getCache,\r\n getCachePath\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides methods for initializing Highcharts with customized\r\n * animation settings and triggering the creation of Highcharts charts with\r\n * export-specific configurations in the page context. Supports dynamic option\r\n * merging, custom logic injection, and control over rendering behaviors. Used\r\n * by the Puppeteer page.\r\n */\r\n\r\n/* eslint-disable no-undef */\r\n\r\n/**\r\n * Setting the `Highcharts.animObject` function. Called when initing the page.\r\n *\r\n * @function setupHighcharts\r\n */\r\nexport function setupHighcharts() {\r\n Highcharts.animObject = function () {\r\n return { duration: 0 };\r\n };\r\n}\r\n\r\n/**\r\n * Creates the actual Highcharts chart on a page.\r\n *\r\n * @async\r\n * @function createChart\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n */\r\nexport async function createChart(exportOptions, customLogicOptions) {\r\n // Get required functions\r\n const { getOptions, setOptions, merge, wrap } = Highcharts;\r\n\r\n // Create a separate object for a potential `setOptions` usages in order\r\n // to prevent from polluting other exports that can happen on the same page\r\n Highcharts.setOptionsObj = merge(false, {}, getOptions());\r\n\r\n // NOTE: Is this used for anything useful?\r\n window.isRenderComplete = false;\r\n wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, cb) {\r\n // Override the `userOptions` with image friendly options\r\n userOptions = merge(userOptions, {\r\n exporting: {\r\n enabled: false\r\n },\r\n plotOptions: {\r\n series: {\r\n label: {\r\n enabled: false\r\n }\r\n }\r\n },\r\n /* Expects tooltip in the `userOptions` when `forExport` is true.\r\n https://github.com/highcharts/highcharts/blob/3ad430a353b8056b9e764aa4e5cd6828aa479db2/js/parts/Chart.js#L241\r\n */\r\n tooltip: {}\r\n });\r\n\r\n (userOptions.series || []).forEach(function (series) {\r\n series.animation = false;\r\n });\r\n\r\n // Add flag to know if chart render has been called.\r\n if (!window.onHighchartsRender) {\r\n window.onHighchartsRender = Highcharts.addEvent(this, 'render', () => {\r\n window.isRenderComplete = true;\r\n });\r\n }\r\n\r\n proceed.apply(this, [userOptions, cb]);\r\n });\r\n\r\n wrap(Highcharts.Series.prototype, 'init', function (proceed, chart, options) {\r\n proceed.apply(this, [chart, options]);\r\n });\r\n\r\n // Some mandatory additional `chart` and `exporting` options\r\n const additionalOptions = {\r\n chart: {\r\n // By default animation is disabled\r\n animation: false,\r\n // Get the right size values\r\n height: exportOptions.height,\r\n width: exportOptions.width\r\n },\r\n exporting: {\r\n // No need for the exporting button\r\n enabled: false\r\n }\r\n };\r\n\r\n // Get the input to export from the `instr` option\r\n const userOptions = new Function(`return ${exportOptions.instr}`)();\r\n\r\n // Get the `themeOptions` option\r\n const themeOptions = new Function(`return ${exportOptions.themeOptions}`)();\r\n\r\n // Merge the following options objects to create final options\r\n const finalOptions = merge(\r\n false,\r\n themeOptions,\r\n userOptions,\r\n // Placed it here instead in the init because of the size issues\r\n additionalOptions\r\n );\r\n\r\n // Prepare the `callback` option\r\n const finalCallback = customLogicOptions.callback\r\n ? new Function(`return ${customLogicOptions.callback}`)()\r\n : null;\r\n\r\n // Trigger the `customCode` option\r\n if (customLogicOptions.customCode) {\r\n new Function('options', customLogicOptions.customCode)(userOptions);\r\n }\r\n\r\n // Get the `globalOptions` option\r\n const globalOptions = new Function(`return ${exportOptions.globalOptions}`)();\r\n\r\n // Set the global options if exist\r\n if (globalOptions) {\r\n setOptions(globalOptions);\r\n }\r\n\r\n // Call the chart creation\r\n Highcharts[exportOptions.constr]('container', finalOptions, finalCallback);\r\n\r\n // Get all images from within the chart\r\n const images = Array.from(\r\n document.querySelectorAll('.highcharts-container image')\r\n );\r\n\r\n // Wait for all images for 2 seconds\r\n await Promise.race([\r\n Promise.all(\r\n images.map((image) =>\r\n image.complete && image.naturalHeight !== 0\r\n ? Promise.resolve()\r\n : new Promise((resolve) =>\r\n image.addEventListener('load', resolve, { once: true })\r\n )\r\n )\r\n ),\r\n // Proceed further even if images did not load\r\n new Promise((resolve) => setTimeout(resolve, 2000))\r\n ]);\r\n\r\n // Get the current global options\r\n const defaultOptions = getOptions();\r\n\r\n // Clear it just in case (e.g. the `setOptions` was used in the `customCode`)\r\n for (const prop in defaultOptions) {\r\n if (typeof defaultOptions[prop] !== 'function') {\r\n delete defaultOptions[prop];\r\n }\r\n }\r\n\r\n // Set the default options back\r\n setOptions(Highcharts.setOptionsObj);\r\n\r\n // Empty the custom global options object\r\n Highcharts.setOptionsObj = {};\r\n}\r\n\r\nexport default {\r\n setupHighcharts,\r\n createChart\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions for managing Puppeteer browser\r\n * instance, creating and clearing pages, injecting custom JS and CSS resources,\r\n * and setting up Highcharts for server-side rendering. The module ensures\r\n * that the browser and pages are correctly managed and can handle failures\r\n * during operations like launching the browser or creating new pages.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport puppeteer from 'puppeteer';\r\n\r\nimport { getCachePath } from './cache.js';\r\nimport { getOptions } from './config.js';\r\nimport { setupHighcharts } from './highcharts.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { __dirname, getAbsolutePath } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// Get the template for pages\r\nconst pageTemplate = readFileSync(\r\n join(__dirname, 'templates', 'template.html'),\r\n 'utf8'\r\n);\r\n\r\n// To save the browser\r\nlet browser = null;\r\n\r\n/**\r\n * Retrieves the existing Puppeteer browser instance.\r\n *\r\n * @function getBrowser\r\n *\r\n * @returns {Object} The Puppeteer browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been created.\r\n */\r\nexport function getBrowser() {\r\n if (!browser) {\r\n throw new ExportError('[browser] No valid browser has been created.', 500);\r\n }\r\n return browser;\r\n}\r\n\r\n/**\r\n * Creates a Puppeteer browser instance with the specified arguments.\r\n *\r\n * @async\r\n * @function createBrowser\r\n *\r\n * @param {Array} puppeteerArgs - Additional arguments for Puppeteer\r\n * browser's launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to the created Puppeteer\r\n * browser instance.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if max retries to open\r\n * a browser instance are reached, or if no browser instance is found after\r\n * retries.\r\n */\r\nexport async function createBrowser(puppeteerArgs) {\r\n // Get `debug` and `other` options\r\n const { debug, other } = getOptions();\r\n\r\n // Get the `debug` options\r\n const { enable: enabledDebug, ...debugOptions } = debug;\r\n\r\n // Launch options for the browser instance\r\n const launchOptions = {\r\n headless: other.browserShellMode ? 'shell' : true,\r\n userDataDir: 'tmp',\r\n args: puppeteerArgs || [],\r\n handleSIGINT: false,\r\n handleSIGTERM: false,\r\n handleSIGHUP: false,\r\n waitForInitialPage: false,\r\n defaultViewport: null,\r\n ...(enabledDebug && debugOptions)\r\n };\r\n\r\n // Create a browser\r\n if (!browser) {\r\n // A counter for the browser's launch retries\r\n let tryCount = 0;\r\n const openBrowser = async () => {\r\n try {\r\n log(\r\n 3,\r\n `[browser] Attempting to launch and get a browser instance (try ${++tryCount}).`\r\n );\r\n\r\n // Launch the browser\r\n browser = await puppeteer.launch(launchOptions);\r\n } catch (error) {\r\n logWithStack(\r\n 1,\r\n error,\r\n '[browser] Failed to launch a browser instance.'\r\n );\r\n\r\n // Retry to launch browser until reaching max attempts\r\n if (tryCount < 25) {\r\n log(3, `[browser] Retry to open a browser (${tryCount} out of 25).`);\r\n\r\n // Wait for a 4 seconds before trying again\r\n await new Promise((response) => setTimeout(response, 4000));\r\n await openBrowser();\r\n } else {\r\n throw error;\r\n }\r\n }\r\n };\r\n\r\n try {\r\n // Try to open a browser\r\n await openBrowser();\r\n\r\n // Shell mode inform\r\n if (launchOptions.headless === 'shell') {\r\n log(3, `[browser] Launched browser in shell mode.`);\r\n }\r\n\r\n // Debug mode inform\r\n if (enabledDebug) {\r\n log(3, `[browser] Launched browser in debug mode.`);\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[browser] Maximum retries to open a browser instance reached.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // No correct browser\r\n if (!browser) {\r\n throw new ExportError('[browser] Cannot find a browser to open.', 500);\r\n }\r\n }\r\n\r\n // Return a browser instance\r\n return browser;\r\n}\r\n\r\n/**\r\n * Closes the Puppeteer browser instance if it is connected.\r\n *\r\n * @async\r\n * @function closeBrowser\r\n */\r\nexport async function closeBrowser() {\r\n // Close the browser when connected\r\n if (browser && browser.connected) {\r\n await browser.close();\r\n }\r\n browser = null;\r\n log(4, '[browser] Closed the browser.');\r\n}\r\n\r\n/**\r\n * Creates a new Puppeteer page within an existing browser instance.\r\n * The function creates a new page, disables caching, sets content using\r\n * the `_setPageContent()`, and returns the created Puppeteer page.\r\n *\r\n * @async\r\n * @function newPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains `id`,\r\n * `workCount`, and `page`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if no valid browser\r\n * has been connected or if a page is invalid or closed.\r\n */\r\nexport async function newPage(poolResource) {\r\n // Error in case of no connected browser\r\n if (!browser || !browser.connected) {\r\n throw new ExportError(`[browser] Browser is not yet connected.`, 500);\r\n }\r\n\r\n // Create a page\r\n poolResource.page = await browser.newPage();\r\n\r\n // Disable cache\r\n await poolResource.page.setCacheEnabled(false);\r\n\r\n // Set the content\r\n await _setPageContent(poolResource.page);\r\n\r\n // Set page events\r\n _setPageEvents(poolResource.page);\r\n\r\n // Check if the page is correctly created\r\n if (!poolResource.page || poolResource.page.isClosed()) {\r\n throw new ExportError('[browser] The page is invalid or closed.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Clears the content of a Puppeteer page based on the specified mode. Logs\r\n * thrown error if clearing of a page's content fails.\r\n *\r\n * @async\r\n * @function clearPage\r\n *\r\n * @param {Object} poolResource - The pool resource that contains page and id.\r\n * @param {boolean} [hardReset=false] - A flag indicating the type of clearing\r\n * to be performed. If `true`, navigates to `about:blank` and resets content\r\n * and scripts. If `false`, clears the body content by setting a predefined HTML\r\n * structure. The default value is `false`.\r\n *\r\n * @returns {Promise} A Promise that resolves to `true` when page\r\n * is correctly cleared and `false` when it is not.\r\n */\r\nexport async function clearPage(poolResource, hardReset = false) {\r\n try {\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n if (hardReset) {\r\n // Navigate to `about:blank`\r\n await poolResource.page.goto('about:blank', {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n\r\n // Set the content and and scripts again\r\n await _setPageContent(poolResource.page);\r\n } else {\r\n // Clear body content\r\n await poolResource.page.evaluate(() => {\r\n document.body.innerHTML =\r\n '
';\r\n });\r\n }\r\n return true;\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[pool] Pool resource [${poolResource.id}] - Content of the page could not be cleared.`\r\n );\r\n\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n poolResource.workCount = getOptions().pool.workLimit + 1;\r\n }\r\n return false;\r\n}\r\n\r\n/**\r\n * Adds custom JS and CSS resources to a Puppeteer page based on the specified\r\n * options.\r\n *\r\n * @async\r\n * @function addPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object to which resources will\r\n * be added.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise>} A Promise that resolves to an array\r\n * of injected resources.\r\n */\r\nexport async function addPageResources(page, customLogicOptions) {\r\n // Injected resources array\r\n const injectedResources = [];\r\n\r\n // Use the content of the `resources`\r\n const resources = customLogicOptions.resources;\r\n if (resources) {\r\n const injectedJs = [];\r\n\r\n // Load custom JS code\r\n if (resources.js) {\r\n injectedJs.push({\r\n content: resources.js\r\n });\r\n }\r\n\r\n // Load scripts from all custom files\r\n if (resources.files) {\r\n for (const file of resources.files) {\r\n const isLocal = file.startsWith('http') ? false : true;\r\n\r\n // Add each custom script from resources' files\r\n injectedJs.push(\r\n isLocal\r\n ? {\r\n content: readFileSync(getAbsolutePath(file), 'utf8')\r\n }\r\n : {\r\n url: file\r\n }\r\n );\r\n }\r\n }\r\n\r\n // The actual injection of collected scripts\r\n for (const jsResource of injectedJs) {\r\n try {\r\n injectedResources.push(await page.addScriptTag(jsResource));\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] The JS resource cannot be loaded.`);\r\n }\r\n }\r\n injectedJs.length = 0;\r\n\r\n // Load CSS\r\n const injectedCss = [];\r\n if (resources.css) {\r\n const cssImports = resources.css.match(/@import\\s*([^;]*);/g);\r\n if (cssImports) {\r\n // Handle css section\r\n for (let cssImportPath of cssImports) {\r\n if (cssImportPath) {\r\n cssImportPath = cssImportPath\r\n .replace('url(', '')\r\n .replace('@import', '')\r\n .replace(/\"/g, '')\r\n .replace(/'/g, '')\r\n .replace(/;/, '')\r\n .replace(/\\)/g, '')\r\n .trim();\r\n\r\n // Add each custom css from resources\r\n if (cssImportPath.startsWith('http')) {\r\n injectedCss.push({\r\n url: cssImportPath\r\n });\r\n } else if (customLogicOptions.allowFileResources) {\r\n injectedCss.push({\r\n path: getAbsolutePath(cssImportPath)\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n // The rest of the CSS section will be content by now\r\n injectedCss.push({\r\n content: resources.css.replace(/@import\\s*([^;]*);/g, '') || ' '\r\n });\r\n\r\n // The actual injection of collected CSS\r\n for (const cssResource of injectedCss) {\r\n try {\r\n injectedResources.push(await page.addStyleTag(cssResource));\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[browser] The CSS resource cannot be loaded.`\r\n );\r\n }\r\n }\r\n injectedCss.length = 0;\r\n }\r\n }\r\n return injectedResources;\r\n}\r\n\r\n/**\r\n * Clears out all state set on the page with `addScriptTag` and `addStyleTag`.\r\n * Removes injected resources and resets CSS and script tags on the page.\r\n * Additionally, it destroys previously existing charts.\r\n *\r\n * @async\r\n * @function clearPageResources\r\n *\r\n * @param {Object} page - The Puppeteer page object from which resources will\r\n * be cleared.\r\n * @param {Array} injectedResources - Array of injected resources\r\n * to be cleared.\r\n */\r\nexport async function clearPageResources(page, injectedResources) {\r\n try {\r\n for (const resource of injectedResources) {\r\n await resource.dispose();\r\n }\r\n\r\n // Destroy old charts after export is done and reset all CSS and script tags\r\n await page.evaluate(() => {\r\n // We are not guaranteed that Highcharts is loaded, when doing SVG exports\r\n if (typeof Highcharts !== 'undefined') {\r\n // eslint-disable-next-line no-undef\r\n const oldCharts = Highcharts.charts;\r\n\r\n // Check in any already existing charts\r\n if (Array.isArray(oldCharts) && oldCharts.length) {\r\n // Destroy old charts\r\n for (const oldChart of oldCharts) {\r\n oldChart && oldChart.destroy();\r\n // eslint-disable-next-line no-undef\r\n Highcharts.charts.shift();\r\n }\r\n }\r\n }\r\n\r\n // eslint-disable-next-line no-undef\r\n const [...scriptsToRemove] = document.getElementsByTagName('script');\r\n // eslint-disable-next-line no-undef\r\n const [, ...stylesToRemove] = document.getElementsByTagName('style');\r\n // eslint-disable-next-line no-undef\r\n const [...linksToRemove] = document.getElementsByTagName('link');\r\n\r\n // Remove tags\r\n for (const element of [\r\n ...scriptsToRemove,\r\n ...stylesToRemove,\r\n ...linksToRemove\r\n ]) {\r\n element.remove();\r\n }\r\n });\r\n } catch (error) {\r\n logWithStack(2, error, `[browser] Could not clear page's resources.`);\r\n }\r\n}\r\n\r\n/**\r\n * Sets the content for a Puppeteer page using a predefined template\r\n * and additional scripts.\r\n *\r\n * @async\r\n * @function _setPageContent\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the content\r\n * is being set.\r\n */\r\nasync function _setPageContent(page) {\r\n // Set the initial page content\r\n await page.setContent(pageTemplate, { waitUntil: 'domcontentloaded' });\r\n\r\n // Add all registered Higcharts scripts, quite demanding\r\n await page.addScriptTag({ path: join(getCachePath(), 'sources.js') });\r\n\r\n // Set the initial `animObject` for Highcharts\r\n await page.evaluate(setupHighcharts);\r\n}\r\n\r\n/**\r\n * Set events (like `pageerror` and `console`) for a Puppeteer page in order\r\n * to catch and display errors and console logs from the window context.\r\n *\r\n * @function _setPageEvents\r\n *\r\n * @param {Object} page - The Puppeteer page object to which the listeners\r\n * are being set.\r\n */\r\nfunction _setPageEvents(page) {\r\n // Get `debug` options\r\n const { debug } = getOptions();\r\n\r\n // Set the `pageerror` listener\r\n page.on('pageerror', async () => {\r\n // It would seem like this may fire at the same time or shortly before\r\n // a page is closed.\r\n if (page.isClosed()) {\r\n return;\r\n }\r\n });\r\n\r\n // Set the `console` listener, if needed\r\n if (debug.enable && debug.listenToConsole) {\r\n page.on('console', (message) => {\r\n console.log(`[debug] ${message.text()}`);\r\n });\r\n }\r\n}\r\n\r\nexport default {\r\n getBrowser,\r\n createBrowser,\r\n closeBrowser,\r\n newPage,\r\n clearPage,\r\n addPageResources,\r\n clearPageResources\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * The CSS to be used on the exported page.\r\n *\r\n * @returns {string} The CSS configuration.\r\n */\r\nexport default () => `\r\n\r\nhtml, body {\r\n margin: 0;\r\n padding: 0;\r\n box-sizing: border-box;\r\n}\r\n\r\n#table-div, #sliders, #datatable, #controls, .ld-row {\r\n display: none;\r\n height: 0;\r\n}\r\n\r\n#chart-container {\r\n box-sizing: border-box;\r\n margin: 0;\r\n overflow: auto;\r\n font-size: 0;\r\n}\r\n\r\n#chart-container > figure, div {\r\n margin-top: 0 !important;\r\n margin-bottom: 0 !important;\r\n}\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\nimport cssTemplate from './css.js';\r\n\r\n/**\r\n * The SVG template to use when loading SVG content to be exported.\r\n *\r\n * @param {string} svg - The SVG input content to be exported.\r\n *\r\n * @returns {string} The SVG template.\r\n */\r\nexport default (svg) => `\r\n\r\n\r\n \r\n \r\n Highcharts Export\r\n \r\n \r\n \r\n
\r\n ${svg}\r\n
\r\n \r\n\r\n\r\n`;\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module handles chart export functionality using Puppeteer.\r\n * It supports exporting charts as SVG, PNG, JPEG, and PDF formats. The module\r\n * manages page resources, sets up the export environment, and processes chart\r\n * configurations or SVG inputs for rendering. Exports to a chart from a page\r\n * using Puppeteer.\r\n */\r\n\r\nimport { addPageResources, clearPageResources } from './browser.js';\r\nimport { createChart } from './highcharts.js';\r\nimport { log } from './logger.js';\r\n\r\nimport svgTemplate from '../templates/svgExport/svgExport.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n/**\r\n * Exports to a chart from a page using Puppeteer.\r\n *\r\n * @async\r\n * @function puppeteerExport\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @returns {Promise<(string|Buffer|ExportError)>} A Promise that resolves\r\n * to the exported data or rejecting with an `ExportError`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if export to an unsupported\r\n * output format occurs.\r\n */\r\nexport async function puppeteerExport(page, exportOptions, customLogicOptions) {\r\n // Injected resources array (additional JS and CSS)\r\n const injectedResources = [];\r\n\r\n try {\r\n let isSVG = false;\r\n\r\n // Decide on the export method\r\n if (exportOptions.svg) {\r\n log(4, '[export] Treating as SVG input.');\r\n\r\n // If the `type` is also SVG, return the input\r\n if (exportOptions.type === 'svg') {\r\n return exportOptions.svg;\r\n }\r\n\r\n // Mark as SVG export for the later size corrections\r\n isSVG = true;\r\n\r\n // SVG export\r\n await page.setContent(svgTemplate(exportOptions.svg), {\r\n waitUntil: 'domcontentloaded'\r\n });\r\n } else {\r\n log(4, '[export] Treating as JSON config.');\r\n\r\n // Options export\r\n await page.evaluate(createChart, exportOptions, customLogicOptions);\r\n }\r\n\r\n // Keeps track of all resources added on the page with addXXXTag. etc\r\n // It's VITAL that all added resources ends up here so we can clear things\r\n // out when doing a new export in the same page!\r\n injectedResources.push(\r\n ...(await addPageResources(page, customLogicOptions))\r\n );\r\n\r\n // Get the real chart size and set the zoom accordingly\r\n const size = await _getChartSize(page, isSVG, exportOptions.scale);\r\n\r\n // Get the clip region for the page\r\n const { x, y } = await _getClipRegion(page);\r\n\r\n // Set final `height` for viewport\r\n const viewportHeight = Math.abs(\r\n Math.ceil(size.chartHeight || exportOptions.height)\r\n );\r\n\r\n // Set final `width` for viewport\r\n const viewportWidth = Math.abs(\r\n Math.ceil(size.chartWidth || exportOptions.width)\r\n );\r\n\r\n // Set the final viewport now that we have the real height\r\n await page.setViewport({\r\n height: viewportHeight,\r\n width: viewportWidth,\r\n deviceScaleFactor: isSVG ? 1 : parseFloat(exportOptions.scale)\r\n });\r\n\r\n let result;\r\n // Rasterization process\r\n switch (exportOptions.type) {\r\n case 'svg':\r\n result = await _createSVG(page);\r\n break;\r\n case 'png':\r\n case 'jpeg':\r\n result = await _createImage(\r\n page,\r\n exportOptions.type,\r\n {\r\n width: viewportWidth,\r\n height: viewportHeight,\r\n x,\r\n y\r\n },\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n case 'pdf':\r\n result = await _createPDF(\r\n page,\r\n viewportHeight,\r\n viewportWidth,\r\n exportOptions.rasterizationTimeout\r\n );\r\n break;\r\n default:\r\n throw new ExportError(\r\n `[export] Unsupported output format: ${exportOptions.type}.`,\r\n 400\r\n );\r\n }\r\n\r\n // Clear previously injected JS and CSS resources\r\n await clearPageResources(page, injectedResources);\r\n return result;\r\n } catch (error) {\r\n await clearPageResources(page, injectedResources);\r\n return error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the clipping region coordinates of the specified page element\r\n * with the 'chart-container' id.\r\n *\r\n * @async\r\n * @function _getClipRegion\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * `x`, `y`, `width`, and `height` properties.\r\n */\r\nasync function _getClipRegion(page) {\r\n return page.$eval('#chart-container', (element) => {\r\n const { x, y, width, height } = element.getBoundingClientRect();\r\n return {\r\n x,\r\n y,\r\n width,\r\n height: Math.trunc(height > 1 ? height : 500)\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Retrieves the real chart dimensions from a Puppeteer page. The function\r\n * behaves differently based on whether the export type is SVG or another\r\n * format.\r\n *\r\n * @async\r\n * @function _getChartSize\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {boolean} isSVG - Determines whether the chart being processed\r\n * is an SVG or another format.\r\n * @param {number} scale - The scale factor to be applied to the chart\r\n * dimensions.\r\n *\r\n * @returns {Promise} A Promise that resolves to an object containing\r\n * the actual height and width of the chart after scaling.\r\n */\r\nasync function _getChartSize(page, isSVG, scale) {\r\n // Trigger appropriate function based on the `isSvg` flag to get chart size\r\n return isSVG\r\n ? await page.evaluate((scale) => {\r\n const svgElement = document.querySelector(\r\n '#chart-container svg:first-of-type'\r\n );\r\n\r\n // Get the values correctly scaled\r\n const chartHeight = svgElement.height.baseVal.value * scale;\r\n const chartWidth = svgElement.width.baseVal.value * scale;\r\n\r\n // In case of SVG the zoom must be set directly for body as scale\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = scale;\r\n\r\n // Set the margin to 0px\r\n // eslint-disable-next-line no-undef\r\n document.body.style.margin = '0px';\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n }, parseFloat(scale))\r\n : await page.evaluate(() => {\r\n // eslint-disable-next-line no-undef\r\n const { chartHeight, chartWidth } = window.Highcharts.charts[0];\r\n\r\n // No need for such scale manipulation in case of other types\r\n // of exports. Reset the zoom for other exports than to SVGs\r\n // eslint-disable-next-line no-undef\r\n document.body.style.zoom = 1;\r\n\r\n return {\r\n chartHeight,\r\n chartWidth\r\n };\r\n });\r\n}\r\n\r\n/**\r\n * Creates an SVG by evaluating the `outerHTML` of the first 'svg' element\r\n * inside an element with the id 'container'.\r\n *\r\n * @async\r\n * @function _createSVG\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n *\r\n * @returns {Promise} A Promise that resolves to the SVG string.\r\n */\r\nasync function _createSVG(page) {\r\n return page.$eval(\r\n '#container svg:first-of-type',\r\n (element) => element.outerHTML\r\n );\r\n}\r\n\r\n/**\r\n * Creates an image using Puppeteer's page `screenshot` functionality with\r\n * specified options.\r\n *\r\n * @async\r\n * @function _createImage\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {string} type - Image type.\r\n * @param {Object} clip - Clipping region coordinates.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the image buffer\r\n * or rejecting with an `ExportError` for timeout.\r\n */\r\nasync function _createImage(page, type, clip, rasterizationTimeout) {\r\n return Promise.race([\r\n page.screenshot({\r\n type,\r\n clip,\r\n encoding: 'base64',\r\n fullPage: false,\r\n optimizeForSpeed: true,\r\n captureBeyondViewport: true,\r\n ...(type !== 'png' ? { quality: 80 } : {}),\r\n // Always render on a transparent page if the expected type format is PNG\r\n omitBackground: type == 'png' // #447, #463\r\n }),\r\n new Promise((_resolve, reject) =>\r\n setTimeout(\r\n () => reject(new ExportError('Rasterization timeout', 408)),\r\n rasterizationTimeout || 1500\r\n )\r\n )\r\n ]);\r\n}\r\n\r\n/**\r\n * Creates a PDF using Puppeteer's page `pdf` functionality with specified\r\n * options.\r\n *\r\n * @async\r\n * @function _createPDF\r\n *\r\n * @param {Object} page - Puppeteer page object.\r\n * @param {number} height - PDF height.\r\n * @param {number} width - PDF width.\r\n * @param {number} rasterizationTimeout - Timeout for rasterization\r\n * in milliseconds.\r\n *\r\n * @returns {Promise} A Promise that resolves to the PDF buffer.\r\n */\r\nasync function _createPDF(page, height, width, rasterizationTimeout) {\r\n await page.emulateMediaType('screen');\r\n return page.pdf({\r\n // This will remove an extra empty page in PDF exports\r\n height: height + 1,\r\n width,\r\n encoding: 'base64',\r\n timeout: rasterizationTimeout || 1500\r\n });\r\n}\r\n\r\nexport default {\r\n puppeteerExport\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides a worker pool implementation for managing\r\n * the browser instance and pages, specifically designed for use with\r\n * the Highcharts Export Server. It optimizes resources usage and performance\r\n * by maintaining a pool of workers that can handle concurrent export tasks\r\n * using Puppeteer.\r\n */\r\n\r\nimport { Pool } from 'tarn';\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { clearPage, createBrowser, closeBrowser, newPage } from './browser.js';\r\nimport { puppeteerExport } from './export.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getNewDateTime, measureTime } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The pool instance\r\nlet pool = null;\r\n\r\n// Pool statistics\r\nconst poolStats = {\r\n exportsAttempted: 0,\r\n exportsPerformed: 0,\r\n exportsDropped: 0,\r\n exportsFromSvg: 0,\r\n exportsFromOptions: 0,\r\n exportsFromSvgAttempts: 0,\r\n exportsFromOptionsAttempts: 0,\r\n timeSpent: 0,\r\n timeSpentAverage: 0\r\n};\r\n\r\n/**\r\n * Initializes the export pool with the provided configuration, creating\r\n * a browser instance and setting up worker resources.\r\n *\r\n * @async\r\n * @function initPool\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n * @param {Array} puppeteerArgs - Additional arguments for Puppeteer\r\n * launch.\r\n *\r\n * @returns {Promise} A Promise that resolves to ending the function\r\n * execution when an already initialized pool of resources is found.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not create the pool\r\n * of workers.\r\n */\r\nexport async function initPool(poolOptions, puppeteerArgs) {\r\n // Create a browser instance with the puppeteer arguments\r\n await createBrowser(puppeteerArgs);\r\n\r\n try {\r\n log(\r\n 3,\r\n `[pool] Initializing pool with workers: min ${poolOptions.minWorkers}, max ${poolOptions.maxWorkers}.`\r\n );\r\n\r\n if (pool) {\r\n log(\r\n 4,\r\n '[pool] Already initialized, please kill it before creating a new one.'\r\n );\r\n return;\r\n }\r\n\r\n // Keep an eye on a correct min and max workers number\r\n if (poolOptions.minWorkers > poolOptions.maxWorkers) {\r\n poolOptions.minWorkers = poolOptions.maxWorkers;\r\n }\r\n\r\n // Create a pool along with a minimal number of resources\r\n pool = new Pool({\r\n // Get the `create`, `validate`, and `destroy` functions\r\n ..._factory(poolOptions),\r\n min: poolOptions.minWorkers,\r\n max: poolOptions.maxWorkers,\r\n acquireTimeoutMillis: poolOptions.acquireTimeout,\r\n createTimeoutMillis: poolOptions.createTimeout,\r\n destroyTimeoutMillis: poolOptions.destroyTimeout,\r\n idleTimeoutMillis: poolOptions.idleTimeout,\r\n createRetryIntervalMillis: poolOptions.createRetryInterval,\r\n reapIntervalMillis: poolOptions.reaperInterval,\r\n propagateCreateError: false\r\n });\r\n\r\n // Set events\r\n pool.on('release', async (resource) => {\r\n // Clear page\r\n const clearStatus = await clearPage(resource, false);\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Releasing a worker. Clear page status: ${clearStatus}.`\r\n );\r\n });\r\n\r\n pool.on('destroySuccess', (_eventId, resource) => {\r\n log(\r\n 4,\r\n `[pool] Pool resource [${resource.id}] - Destroyed a worker successfully.`\r\n );\r\n resource.page = null;\r\n });\r\n\r\n const initialResources = [];\r\n // Create an initial number of resources\r\n for (let i = 0; i < poolOptions.minWorkers; i++) {\r\n try {\r\n const resource = await pool.acquire().promise;\r\n initialResources.push(resource);\r\n } catch (error) {\r\n logWithStack(2, error, '[pool] Could not create an initial resource.');\r\n }\r\n }\r\n\r\n // Release the initial number of resources back to the pool\r\n initialResources.forEach((resource) => {\r\n pool.release(resource);\r\n });\r\n\r\n log(\r\n 3,\r\n `[pool] The pool is ready${initialResources.length ? ` with ${initialResources.length} initial resources waiting.` : '.'}`\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[pool] Could not configure and create the pool of workers.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Terminates all workers in the pool, destroys the pool, and closes the browser\r\n * instance.\r\n *\r\n * @async\r\n * @function killPool\r\n *\r\n * @returns {Promise} A Promise that resolves once all workers are\r\n * terminated, the pool is destroyed, and the browser is successfully closed.\r\n */\r\nexport async function killPool() {\r\n log(3, '[pool] Killing pool with all workers and closing browser.');\r\n\r\n // If still alive, destroy the pool of pages before closing a browser\r\n if (pool) {\r\n // Free up not released workers\r\n for (const worker of pool.used) {\r\n pool.release(worker.resource);\r\n }\r\n\r\n // Destroy the pool if it is still available\r\n if (!pool.destroyed) {\r\n await pool.destroy();\r\n log(4, '[pool] Destroyed the pool of resources.');\r\n }\r\n pool = null;\r\n }\r\n\r\n // Close the browser instance\r\n await closeBrowser();\r\n}\r\n\r\n/**\r\n * Processes the export work using a worker from the pool. Acquires a worker\r\n * handle from the pool, performs the export using puppeteer, and releases\r\n * the worker handle back to the pool.\r\n *\r\n * @async\r\n * @function postWork\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to the export result\r\n * and options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the export process.\r\n */\r\nexport async function postWork(options) {\r\n let workerHandle;\r\n\r\n try {\r\n log(4, '[pool] Work received, starting to process.');\r\n\r\n // An export attempt counted\r\n ++poolStats.exportsAttempted;\r\n\r\n // Display the pool information if needed\r\n if (options.pool.benchmarking) {\r\n _getPoolInfo();\r\n }\r\n\r\n // Throw an error in case of lacking the pool instance\r\n if (!pool) {\r\n throw new ExportError(\r\n '[pool] Work received, but pool has not been started.',\r\n 500\r\n );\r\n }\r\n\r\n // The acquire counter\r\n const acquireCounter = measureTime();\r\n\r\n // Try to acquire the worker along with the id, works count and page\r\n try {\r\n log(4, '[pool] Acquiring a worker handle.');\r\n\r\n // Acquire a pool resource\r\n workerHandle = await pool.acquire().promise;\r\n\r\n // Check the page acquire time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Acquiring a worker handle took ${acquireCounter()}ms.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered when acquiring an available entry: ${acquireCounter()}ms.`,\r\n 400\r\n ).setError(error);\r\n }\r\n log(4, '[pool] Acquired a worker handle.');\r\n\r\n if (!workerHandle.page) {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n throw new ExportError(\r\n '[pool] Resolved worker page is invalid: the pool setup is wonky.',\r\n 400\r\n );\r\n }\r\n\r\n log(\r\n 4,\r\n `[pool] Pool resource [${workerHandle.id}] - Starting work on this pool entry.`\r\n );\r\n\r\n // Start measuring export time\r\n const exportCounter = measureTime();\r\n\r\n // Perform an export on a puppeteer level\r\n const exportResult = await puppeteerExport(\r\n workerHandle.page,\r\n options.export,\r\n options.customLogic\r\n );\r\n\r\n // Check if it's an error\r\n if (exportResult instanceof Error) {\r\n // NOTE:\r\n // If there's a rasterization timeout, we want need to flush the page.\r\n // This is because the page may be in a state where it's waiting for\r\n // the screenshot to finish even though the timeout has occured.\r\n // Which of course causes a lot of issues with the event system,\r\n // and page consistency.\r\n //\r\n // Only `page.screenshot` will throw this, timeouts for PDF's are\r\n // handled by the `page.pdf` function itself.\r\n //\r\n // ...yes, this is ugly.\r\n if (exportResult.message === 'Rasterization timeout') {\r\n // Set the `workLimit` to exceeded in order to recreate the resource\r\n workerHandle.workCount = options.pool.workLimit + 1;\r\n workerHandle.page = null;\r\n }\r\n\r\n if (\r\n exportResult.name === 'TimeoutError' ||\r\n exportResult.message === 'Rasterization timeout'\r\n ) {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Rasterization timeout: your chart may be too complex or large, and failed to render within the allotted time.`\r\n ).setError(exportResult);\r\n } else {\r\n throw new ExportError(\r\n `[pool] ${\r\n options.requestId ? `Request [${options.requestId}] - ` : ''\r\n }Error encountered during export: ${exportCounter()}ms.`\r\n ).setError(exportResult);\r\n }\r\n }\r\n\r\n // Check the Puppeteer export time\r\n if (options.server.benchmarking) {\r\n log(\r\n 5,\r\n `[benchmark] ${options.requestId ? `Request [${options.requestId}] - ` : ''}`,\r\n `Exporting a chart sucessfully took ${exportCounter()}ms.`\r\n );\r\n }\r\n\r\n // Release the resource back to the pool\r\n pool.release(workerHandle);\r\n\r\n // Update statistics\r\n poolStats.timeSpent += exportCounter();\r\n poolStats.timeSpentAverage =\r\n poolStats.timeSpent / ++poolStats.exportsPerformed;\r\n\r\n log(4, `[pool] Work completed in ${exportCounter()}ms.`);\r\n\r\n // Otherwise return an object with the result and options\r\n return {\r\n result: exportResult,\r\n options\r\n };\r\n } catch (error) {\r\n ++poolStats.exportsDropped;\r\n\r\n // Try to release the worker, if it exists\r\n if (workerHandle) {\r\n pool.release(workerHandle);\r\n }\r\n\r\n throw error;\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves the current pool instance.\r\n *\r\n * @function getPool\r\n *\r\n * @returns {(Object|null)} The current pool instance if initialized, or `null`\r\n * if the pool has not been created.\r\n */\r\nexport function getPool() {\r\n return pool;\r\n}\r\n\r\n/**\r\n * Gets the statistic of a pool instace about exports.\r\n *\r\n * @function getPoolStats\r\n *\r\n * @returns {Object} The current pool statistics.\r\n */\r\nexport function getPoolStats() {\r\n return poolStats;\r\n}\r\n\r\n/**\r\n * Retrieves pool information in JSON format, including minimum and maximum\r\n * workers, available workers, workers in use, and pending acquire requests.\r\n *\r\n * @function getPoolInfoJSON\r\n *\r\n * @returns {Object} Pool information in JSON format.\r\n */\r\nexport function getPoolInfoJSON() {\r\n return {\r\n min: pool.min,\r\n max: pool.max,\r\n used: pool.numUsed(),\r\n available: pool.numFree(),\r\n allCreated: pool.numUsed() + pool.numFree(),\r\n pendingAcquires: pool.numPendingAcquires(),\r\n pendingCreates: pool.numPendingCreates(),\r\n pendingValidations: pool.numPendingValidations(),\r\n pendingDestroys: pool.pendingDestroys.length,\r\n absoluteAll:\r\n pool.numUsed() +\r\n pool.numFree() +\r\n pool.numPendingAcquires() +\r\n pool.numPendingCreates() +\r\n pool.numPendingValidations() +\r\n pool.pendingDestroys.length\r\n };\r\n}\r\n\r\n/**\r\n * Logs information about the current state of the pool, including the minimum\r\n * and maximum workers, available workers, workers in use, and pending acquire\r\n * requests.\r\n *\r\n * @function _getPoolInfo\r\n */\r\nfunction _getPoolInfo() {\r\n const {\r\n min,\r\n max,\r\n used,\r\n available,\r\n allCreated,\r\n pendingAcquires,\r\n pendingCreates,\r\n pendingValidations,\r\n pendingDestroys,\r\n absoluteAll\r\n } = getPoolInfoJSON();\r\n\r\n log(5, `[pool] The minimum number of resources allowed by pool: ${min}.`);\r\n log(5, `[pool] The maximum number of resources allowed by pool: ${max}.`);\r\n log(5, `[pool] The number of used resources: ${used}.`);\r\n log(5, `[pool] The number of free resources: ${available}.`);\r\n log(\r\n 5,\r\n `[pool] The number of all created (used and free) resources: ${allCreated}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be acquired: ${pendingAcquires}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be created: ${pendingCreates}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be validated: ${pendingValidations}.`\r\n );\r\n log(\r\n 5,\r\n `[pool] The number of resources waiting to be destroyed: ${pendingDestroys}.`\r\n );\r\n log(5, `[pool] The number of all resources: ${absoluteAll}.`);\r\n}\r\n\r\n/**\r\n * Factory function that returns an object with `create`, `validate`, `destroy`\r\n * functions for the pool instance.\r\n *\r\n * @function _factory\r\n *\r\n * @param {Object} poolOptions - The configuration object containing `pool`\r\n * options.\r\n */\r\nfunction _factory(poolOptions) {\r\n return {\r\n /**\r\n * Creates a new worker page for the export pool.\r\n *\r\n * @async\r\n * @function create\r\n *\r\n * @returns {Promise} A Promise that resolves to an object\r\n * containing the worker ID, a reference to the browser page, and initial\r\n * work count.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is an error during\r\n * the creation of the new page.\r\n */\r\n create: async () => {\r\n // Init the resource with unique id and work count\r\n const poolResource = {\r\n id: uuid(),\r\n // Try to distribute the initial work count\r\n workCount: Math.round(Math.random() * (poolOptions.workLimit / 2))\r\n };\r\n\r\n try {\r\n // Start measuring a page creation time\r\n const startDate = getNewDateTime();\r\n\r\n // Create a new page\r\n await newPage(poolResource);\r\n\r\n // Measure the time of full creation and configuration of a page\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Successfully created a worker, took ${\r\n getNewDateTime() - startDate\r\n }ms.`\r\n );\r\n\r\n // Return ready pool resource\r\n return poolResource;\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Error encountered when creating a new page.`\r\n );\r\n throw error;\r\n }\r\n },\r\n\r\n /**\r\n * Validates a worker page in the export pool, checking if it has exceeded\r\n * the work limit.\r\n *\r\n * @async\r\n * @function validate\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n *\r\n * @returns {Promise} A Promise that resolves to true if the worker\r\n * is valid and within the work limit; otherwise, to false.\r\n */\r\n validate: async (poolResource) => {\r\n // NOTE:\r\n // In certain cases acquiring throws a `TargetCloseError`, which may\r\n // be caused by two things:\r\n // - The page is closed and attempted to be reused.\r\n // - Lost contact with the browser.\r\n //\r\n // What we're seeing in logs is that successive exports typically\r\n // succeeds, and the server recovers, indicating that it's likely\r\n // the first case. This is an attempt at allievating the issue by\r\n // simply not validating the worker if the page is null or closed.\r\n //\r\n // The actual result from when this happened, was that a worker would\r\n // be completely locked, stopping it from being acquired until\r\n // its work count reached the limit.\r\n\r\n // Check if the `page` is valid\r\n if (!poolResource.page) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (no valid page is found).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `page` is closed\r\n if (poolResource.page.isClosed()) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page is closed or invalid).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `mainFrame` is detached\r\n if (poolResource.page.mainFrame().detached) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (page's frame is detached).`\r\n );\r\n return false;\r\n }\r\n\r\n // Check if the `workLimit` is exceeded\r\n if (\r\n poolOptions.workLimit &&\r\n ++poolResource.workCount > poolOptions.workLimit\r\n ) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Validation failed (exceeded the ${poolOptions.workLimit} works per resource limit).`\r\n );\r\n return false;\r\n }\r\n\r\n // The `poolResource` is validated\r\n return true;\r\n },\r\n\r\n /**\r\n * Destroys a worker entry in the export pool, closing its associated page.\r\n *\r\n * @async\r\n * @function destroy\r\n *\r\n * @param {Object} poolResource - The handle to the worker, containing\r\n * the worker's ID, a reference to the browser page, and work count.\r\n */\r\n destroy: async (poolResource) => {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Destroying a worker.`\r\n );\r\n\r\n if (poolResource.page && !poolResource.page.isClosed()) {\r\n try {\r\n // Remove all attached event listeners from the resource\r\n poolResource.page.removeAllListeners('pageerror');\r\n poolResource.page.removeAllListeners('console');\r\n poolResource.page.removeAllListeners('framedetached');\r\n\r\n // We need to wait around for this\r\n await poolResource.page.close();\r\n } catch (error) {\r\n log(\r\n 3,\r\n `[pool] Pool resource [${poolResource.id}] - Page could not be closed upon destroying.`\r\n );\r\n throw error;\r\n }\r\n }\r\n }\r\n };\r\n}\r\n\r\nexport default {\r\n initPool,\r\n killPool,\r\n postWork,\r\n getPool,\r\n getPoolStats,\r\n getPoolInfoJSON\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Used to sanitize the strings coming from the exporting module\r\n * to prevent XSS attacks (with the DOMPurify library).\r\n */\r\n\r\nimport DOMPurify from 'dompurify';\r\nimport { JSDOM } from 'jsdom';\r\n\r\n/**\r\n * Sanitizes a given HTML string by removing \r\n * tags and any content within them.\r\n *\r\n * @function sanitize\r\n *\r\n * @param {string} input - The HTML string to be sanitized.\r\n *\r\n * @returns {string} The sanitized HTML string.\r\n */\r\nexport function sanitize(input) {\r\n // Get the virtual DOM\r\n const window = new JSDOM('').window;\r\n\r\n // Create a purifying instance\r\n const purify = DOMPurify(window);\r\n\r\n // Return sanitized input, allowing for the `foreignObject` elements\r\n return purify.sanitize(input, { ADD_TAGS: ['foreignObject'] });\r\n}\r\n\r\nexport default {\r\n sanitize\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides functions that prepare for the exporting\r\n * charts into various image output formats such as JPEG, PNG, PDF, and SVGs.\r\n * It supports single and batch export operations and allows customization\r\n * through options passed from configurations or APIs.\r\n */\r\n\r\nimport { readFileSync, writeFileSync } from 'fs';\r\n\r\nimport { isAllowedConfig, updateOptions, validateOption } from './config.js';\r\nimport { log, logWithStack } from './logger.js';\r\nimport { getPoolStats, killPool, postWork } from './pool.js';\r\nimport { sanitize } from './sanitize.js';\r\nimport { getAbsolutePath, getBase64, isObject, roundNumber } from './utils.js';\r\n\r\nimport ExportError from './errors/ExportError.js';\r\n\r\n// The global flag for the code execution permission\r\nlet allowCodeExecution = false;\r\n\r\n/**\r\n * Starts a single export process based on the specified options and saves\r\n * the resulting image to the provided output file.\r\n *\r\n * @async\r\n * @function singleExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. The object must contain at least one\r\n * of the following `export` properties: `infile`, `instr`, `options`, or `svg`\r\n * to generate a valid image.\r\n *\r\n * @returns {Promise} A Promise that resolves once the single export\r\n * process is completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * the single export process.\r\n */\r\nexport async function singleExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export) {\r\n // Perform an export\r\n await startExport(\r\n { export: options.export, customLogic: options.customLogic },\r\n async (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile || `chart.${type}`,\r\n type !== 'svg' ? Buffer.from(data.result, 'base64') : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n\r\n // Kill pool and close browser after finishing single export\r\n await killPool();\r\n }\r\n );\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide one of the following options: `infile`, `instr`, `options`, or `svg` to generate a valid image.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts a batch export process for multiple charts based on information\r\n * provided in the `batch` option. The `batch` is a string in the following\r\n * format: \"infile1.json=outfile1.png;infile2.json=outfile2.png;...\". Results\r\n * are saved to the specified output files.\r\n *\r\n * @async\r\n * @function batchExport\r\n *\r\n * @param {Object} options - The `options` object, which should include settings\r\n * from the `export` and `customLogic` sections. It can be a partial or complete\r\n * set of options from these sections. It must contain the `batch` option from\r\n * the `export` section to generate valid images.\r\n *\r\n * @returns {Promise} A Promise that resolves once the batch export\r\n * processes are completed.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if an error occurs during\r\n * any of the batch export process.\r\n */\r\nexport async function batchExport(options) {\r\n // Check if the export makes sense\r\n if (options && options.export && options.export.batch) {\r\n // An array for collecting batch exports\r\n const batchFunctions = [];\r\n\r\n // Split and pair the `batch` arguments\r\n for (let pair of options.export.batch.split(';') || []) {\r\n pair = pair.split('=');\r\n if (pair.length === 2) {\r\n batchFunctions.push(\r\n startExport(\r\n {\r\n export: {\r\n ...options.export,\r\n infile: pair[0],\r\n outfile: pair[1]\r\n },\r\n customLogic: options.customLogic\r\n },\r\n (error, data) => {\r\n // Exit process when error exists\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // Get the `b64`, `outfile`, and `type` for a chart\r\n const { b64, outfile, type } = data.options.export;\r\n\r\n // Save the result\r\n try {\r\n if (b64) {\r\n // As a Base64 string to a txt file\r\n writeFileSync(\r\n `${outfile.split('.').shift() || 'chart'}.txt`,\r\n getBase64(data.result, type)\r\n );\r\n } else {\r\n // As a correct image format\r\n writeFileSync(\r\n outfile,\r\n type !== 'svg'\r\n ? Buffer.from(data.result, 'base64')\r\n : data.result\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error while saving a chart.',\r\n 500\r\n ).setError(error);\r\n }\r\n }\r\n )\r\n );\r\n } else {\r\n log(2, '[chart] No correct pair found for the batch export.');\r\n }\r\n }\r\n\r\n // Await all exports are done\r\n const batchResults = await Promise.allSettled(batchFunctions);\r\n\r\n // Kill pool and close browser after finishing batch export\r\n await killPool();\r\n\r\n // Log errors if found\r\n batchResults.forEach((result, index) => {\r\n // Log the error with stack about the specific batch export\r\n if (result.reason) {\r\n logWithStack(\r\n 1,\r\n result.reason,\r\n `[chart] Batch export number ${index + 1} could not be correctly completed.`\r\n );\r\n }\r\n });\r\n } else {\r\n throw new ExportError(\r\n '[chart] No expected `export` options were found. Please provide the `batch` option to generate valid images.',\r\n 400\r\n );\r\n }\r\n}\r\n\r\n/**\r\n * Starts an export process. The `imageOptions` parameter is an object that\r\n * should include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If partial\r\n * options are provided, missing values will be merged with the current global\r\n * options.\r\n *\r\n * The `endCallback` function is invoked upon the completion of the export,\r\n * either successfully or with an error. The `error` object is provided\r\n * as the first argument, and the `data` object is the second, containing\r\n * the Base64 representation of the chart in the `result` property\r\n * and the complete set of options in the `options` property.\r\n *\r\n * @async\r\n * @function startExport\r\n *\r\n * @param {Object} imageOptions - The `imageOptions` object, which should\r\n * include settings from the `export` and `customLogic` sections. It can\r\n * be a partial or complete set of options from these sections. If the provided\r\n * options are partial, missing values will be merged with the current global\r\n * options.\r\n * @param {Function} endCallback - The callback function to be invoked upon\r\n * finalizing the export process or upon encountering an error. The first\r\n * argument is the `error` object, and the second argument is the `data` object,\r\n * which includes the Base64 representation of the chart in the `result`\r\n * property and the full set of options in the `options` property.\r\n *\r\n * @returns {Promise} This function does not return a value directly.\r\n * Instead, it communicates results via the `endCallback`.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is a problem with\r\n * processing input of any type. The error is passed into the `endCallback`\r\n * function and processed there.\r\n */\r\nexport async function startExport(imageOptions, endCallback) {\r\n try {\r\n // Check if provided options are in an object\r\n if (!isObject(imageOptions)) {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the provided `imageOptions`. Needs to be an object.',\r\n 400\r\n );\r\n }\r\n\r\n // Merge additional options to the copy of the instance options\r\n const options = updateOptions(\r\n {\r\n export: imageOptions.export,\r\n customLogic: imageOptions.customLogic\r\n },\r\n true\r\n );\r\n\r\n // Get the `export` options\r\n const exportOptions = options.export;\r\n\r\n // Starting exporting process message\r\n log(4, '[chart] Starting the exporting process.');\r\n\r\n // Export using options from the file as an input\r\n if (exportOptions.infile !== null) {\r\n log(4, '[chart] Attempting to export from a file input.');\r\n\r\n let fileContent;\r\n try {\r\n // Try to read the file to get the string representation\r\n fileContent = readFileSync(\r\n getAbsolutePath(exportOptions.infile),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n throw new ExportError(\r\n '[chart] Error loading content from a file input.',\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Check the file's extension\r\n if (exportOptions.infile.endsWith('.svg')) {\r\n // Set to the `svg` option\r\n exportOptions.svg = validateOption('svg', fileContent);\r\n } else if (exportOptions.infile.endsWith('.json')) {\r\n // Set to the `instr` option\r\n exportOptions.instr = validateOption('instr', fileContent);\r\n } else {\r\n throw new ExportError(\r\n '[chart] Incorrect value of the `infile` option.',\r\n 400\r\n );\r\n }\r\n }\r\n\r\n // Export using SVG as an input\r\n if (exportOptions.svg !== null) {\r\n log(4, '[chart] Attempting to export from an SVG input.');\r\n\r\n // SVG exports attempts counter\r\n ++getPoolStats().exportsFromSvgAttempts;\r\n\r\n // Export from an SVG string\r\n const result = await _exportFromSvg(\r\n sanitize(exportOptions.svg), // #209\r\n options\r\n );\r\n\r\n // SVG exports counter\r\n ++getPoolStats().exportsFromSvg;\r\n\r\n // Pass SVG export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // Export using options as an input\r\n if (exportOptions.instr !== null || exportOptions.options !== null) {\r\n log(4, '[chart] Attempting to export from options input.');\r\n\r\n // Options exports attempts counter\r\n ++getPoolStats().exportsFromOptionsAttempts;\r\n\r\n // Export from options\r\n const result = await _exportFromOptions(\r\n exportOptions.instr || exportOptions.options,\r\n options\r\n );\r\n\r\n // Options exports counter\r\n ++getPoolStats().exportsFromOptions;\r\n\r\n // Pass options export result to the end callback\r\n return endCallback(null, result);\r\n }\r\n\r\n // No input specified, pass an error message to the callback\r\n return endCallback(\r\n new ExportError(\r\n `[chart] No valid input specified. Check if at least one of the following parameters is correctly set: 'infile', 'instr', 'options', or 'svg'.`,\r\n 400\r\n )\r\n );\r\n } catch (error) {\r\n return endCallback(error);\r\n }\r\n}\r\n\r\n/**\r\n * Retrieves and returns the current status of the code execution permission.\r\n *\r\n * @function getAllowCodeExecution\r\n *\r\n * @returns {boolean} The value of the global `allowCodeExecution` option.\r\n */\r\nexport function getAllowCodeExecution() {\r\n return allowCodeExecution;\r\n}\r\n\r\n/**\r\n * Sets the code execution permission based on the provided boolean value.\r\n *\r\n * @function setAllowCodeExecution\r\n *\r\n * @param {boolean} value - The boolean value to be assigned to the global\r\n * `allowCodeExecution` option.\r\n */\r\nexport function setAllowCodeExecution(value) {\r\n allowCodeExecution = value;\r\n}\r\n\r\n/**\r\n * Exports from an SVG based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromSvg\r\n *\r\n * @param {string} inputToExport - The SVG based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct SVG\r\n * input.\r\n */\r\nasync function _exportFromSvg(inputToExport, options) {\r\n // Check if it is SVG\r\n if (\r\n typeof inputToExport === 'string' &&\r\n (inputToExport.indexOf('= 0 || inputToExport.indexOf('= 0)\r\n ) {\r\n log(4, '[chart] Parsing input as SVG.');\r\n\r\n // Set the export input as SVG\r\n options.export.svg = inputToExport;\r\n\r\n // Reset the rest of the export input options\r\n options.export.options = null;\r\n options.export.instr = null;\r\n\r\n // Call the function with an SVG string as an export input\r\n return _prepareExport(options);\r\n } else {\r\n throw new ExportError('[chart] Not a correct SVG input.', 400);\r\n }\r\n}\r\n\r\n/**\r\n * Exports from an options based input with the provided options.\r\n *\r\n * @async\r\n * @function _exportFromOptions\r\n *\r\n * @param {string} inputToExport - The options based input to be exported.\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if there is not a correct\r\n * chart options input.\r\n */\r\nasync function _exportFromOptions(inputToExport, options) {\r\n log(4, '[chart] Parsing input from options.');\r\n\r\n // Try to check, validate and parse to stringified options\r\n const stringifiedOptions = isAllowedConfig(\r\n inputToExport,\r\n true,\r\n options.customLogic.allowCodeExecution\r\n );\r\n\r\n // Check if a correct stringified options\r\n if (\r\n stringifiedOptions === null ||\r\n typeof stringifiedOptions !== 'string' ||\r\n !stringifiedOptions.startsWith('{') ||\r\n !stringifiedOptions.endsWith('}')\r\n ) {\r\n throw new ExportError(\r\n '[chart] Invalid configuration provided - Only options configurations and SVG are allowed for this server. If this is your server, JavaScript custom code can be enabled by starting the server with the `allowCodeExecution` options set to true.',\r\n 403\r\n );\r\n }\r\n\r\n // Set the export input as a stringified chart options\r\n options.export.instr = stringifiedOptions;\r\n\r\n // Reset the rest of the export input options\r\n options.export.options = null;\r\n options.export.svg = null;\r\n\r\n // Call the function with a stringified chart options\r\n return _prepareExport(options);\r\n}\r\n\r\n/**\r\n * Function for finalizing options and configurations before export.\r\n *\r\n * @async\r\n * @function _prepareExport\r\n *\r\n * @param {Object} options - The configuration object containing complete set\r\n * of options.\r\n *\r\n * @returns {Promise} A Promise that resolves to a result of the export\r\n * process.\r\n */\r\nasync function _prepareExport(options) {\r\n // Get the `export` and `customLogic` options\r\n const { export: exportOptions, customLogic: customLogicOptions } = options;\r\n\r\n // Prepare the `constr` option\r\n exportOptions.constr = _fixConstr(exportOptions.constr);\r\n\r\n // Prepare the `type` option\r\n exportOptions.type = _fixType(exportOptions.type, exportOptions.outfile);\r\n\r\n // Prepare the `outfile` option\r\n exportOptions.outfile = _fixOutfile(\r\n exportOptions.type,\r\n exportOptions.outfile\r\n );\r\n\r\n // Notify about the custom logic usage status\r\n log(\r\n 3,\r\n `[chart] The custom logic is ${customLogicOptions.allowCodeExecution ? 'allowed' : 'disallowed'}.`\r\n );\r\n\r\n // Prepare the `customCode`, `callback`, and `resources` options\r\n _handleCustomLogic(customLogicOptions);\r\n\r\n // Prepare the `globalOptions` and `themeOptions` options\r\n _handleGlobalAndTheme(exportOptions, customLogicOptions);\r\n\r\n // Prepare the `height`, `width`, and `scale` options\r\n _handleSize(exportOptions);\r\n\r\n // Check if the image options object does not exceed the size limit\r\n _checkDataSize({ export: exportOptions, customLogic: customLogicOptions });\r\n\r\n // Post the work to the pool\r\n return postWork(options);\r\n}\r\n\r\n/**\r\n * Handles adjusting the constructor name by transforming and normalizing\r\n * it based on common chart types.\r\n *\r\n * @function _fixConstr\r\n *\r\n * @param {string} constr - The original constructor name to be adjusted.\r\n *\r\n * @returns {string} The corrected constructor name, or 'chart' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixConstr(constr) {\r\n try {\r\n // Fix the constructor by lowering casing\r\n const fixedConstr = `${constr.toLowerCase().replace('chart', '')}Chart`;\r\n\r\n // Handle the case where the result is just 'Chart'\r\n if (fixedConstr === 'Chart') {\r\n fixedConstr.toLowerCase();\r\n }\r\n\r\n // Return the corrected constructor, otherwise default to 'chart'\r\n return ['chart', 'stockChart', 'mapChart', 'ganttChart'].includes(\r\n fixedConstr\r\n )\r\n ? fixedConstr\r\n : 'chart';\r\n } catch {\r\n // Default to 'chart' in case of any error\r\n return 'chart';\r\n }\r\n}\r\n\r\n/**\r\n * Handles fixing the outfile based on provided type.\r\n *\r\n * @function _fixOutfile\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} outfile - The file path or name.\r\n *\r\n * @returns {string} The corrected outfile, or 'chart.png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixOutfile(type, outfile) {\r\n // Get the file name from the `outfile` option\r\n const fileName = getAbsolutePath(outfile || 'chart')\r\n .split('.')\r\n .shift();\r\n\r\n // Return a correct outfile\r\n return `${fileName}.${type || 'png'}`;\r\n}\r\n\r\n/**\r\n * Handles fixing the export type based on MIME types and file extensions.\r\n *\r\n * @function _fixType\r\n *\r\n * @param {string} type - The original export type.\r\n * @param {string} [outfile=null] - The file path or name. The default value\r\n * is `null`.\r\n *\r\n * @returns {string} The corrected export type, or 'png' if the input\r\n * is not recognized.\r\n */\r\nfunction _fixType(type, outfile = null) {\r\n // MIME types\r\n const mimeTypes = {\r\n 'image/png': 'png',\r\n 'image/jpeg': 'jpeg',\r\n 'application/pdf': 'pdf',\r\n 'image/svg+xml': 'svg'\r\n };\r\n\r\n // Get formats\r\n const formats = Object.values(mimeTypes);\r\n\r\n // Check if type and outfile's extensions are the same\r\n if (outfile) {\r\n const outType = outfile.split('.').pop();\r\n\r\n // Support the JPG type\r\n if (outType === 'jpg') {\r\n type = 'jpeg';\r\n } else if (formats.includes(outType) && type !== outType) {\r\n type = outType;\r\n }\r\n }\r\n\r\n // Return a correct type\r\n return mimeTypes[type] || formats.find((t) => t === type) || 'png';\r\n}\r\n\r\n/**\r\n * Handle calculating the `height`, `width` and `scale` for chart exports based\r\n * on the provided export options.\r\n *\r\n * The function prioritizes values in the following order:\r\n *\r\n * 1. The `height`, `width`, `scale` from the `exportOptions`.\r\n * 2. Options from the chart configuration (from `exporting` and `chart`).\r\n * 3. Options from the global options (from `exporting` and `chart`).\r\n * 4. Options from the theme options (from `exporting` and `chart` sections).\r\n * 5. Fallback default values (`height = 400`, `width = 600`, `scale = 1`).\r\n *\r\n * @function _handleSize\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n */\r\nfunction _handleSize(exportOptions) {\r\n // Check the `options` and `instr` for chart and exporting sections\r\n const { chart: optionsChart, exporting: optionsExporting } =\r\n isAllowedConfig(exportOptions.instr) || false;\r\n\r\n // Check the `globalOptions` for chart and exporting sections\r\n const { chart: globalOptionsChart, exporting: globalOptionsExporting } =\r\n isAllowedConfig(exportOptions.globalOptions) || false;\r\n\r\n // Check the `themeOptions` for chart and exporting sections\r\n const { chart: themeOptionsChart, exporting: themeOptionsExporting } =\r\n isAllowedConfig(exportOptions.themeOptions) || false;\r\n\r\n // Find the `height` value\r\n const height =\r\n exportOptions.height ||\r\n optionsExporting?.sourceHeight ||\r\n optionsChart?.height ||\r\n globalOptionsExporting?.sourceHeight ||\r\n globalOptionsChart?.height ||\r\n themeOptionsExporting?.sourceHeight ||\r\n themeOptionsChart?.height ||\r\n exportOptions.defaultHeight ||\r\n 400;\r\n\r\n // Find the `width` value\r\n const width =\r\n exportOptions.width ||\r\n optionsExporting?.sourceWidth ||\r\n optionsChart?.width ||\r\n globalOptionsExporting?.sourceWidth ||\r\n globalOptionsChart?.width ||\r\n themeOptionsExporting?.sourceWidth ||\r\n themeOptionsChart?.width ||\r\n exportOptions.defaultWidth ||\r\n 600;\r\n\r\n // Find the `scale` value:\r\n // - Cannot be lower than 0.1\r\n // - Cannot be higher than 5.0\r\n // - Must be rounded to 2 decimal places (e.g. 0.23234 -> 0.23)\r\n const scale = roundNumber(\r\n Math.max(\r\n 0.1,\r\n Math.min(\r\n exportOptions.scale ||\r\n optionsExporting?.scale ||\r\n globalOptionsExporting?.scale ||\r\n themeOptionsExporting?.scale ||\r\n exportOptions.defaultScale ||\r\n 1,\r\n 5.0\r\n )\r\n ),\r\n 2\r\n );\r\n\r\n // Update `height`, `width`, and `scale` information in the `export` options\r\n exportOptions.height = height;\r\n exportOptions.width = width;\r\n exportOptions.scale = scale;\r\n\r\n // Get rid of potential `px` and `%`\r\n for (let param of ['height', 'width', 'scale']) {\r\n if (typeof exportOptions[param] === 'string') {\r\n exportOptions[param] = +exportOptions[param].replace(/px|%/gi, '');\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles the execution of custom logic options, including loading `resources`,\r\n * `customCode`, and `callback`. If code execution is allowed, it processes\r\n * the custom logic options accordingly. If code execution is not allowed,\r\n * it disables the usage of resources, custom code and callback.\r\n *\r\n * @function _handleCustomLogic\r\n *\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if code execution\r\n * is not allowed but custom logic options are still provided.\r\n */\r\nfunction _handleCustomLogic(customLogicOptions) {\r\n // In case of allowing code execution\r\n if (customLogicOptions.allowCodeExecution) {\r\n // Process the `resources` option\r\n try {\r\n // Try to handle resources\r\n customLogicOptions.resources = _handleResources(\r\n customLogicOptions.resources,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate option\r\n customLogicOptions.resources = validateOption(\r\n 'resources',\r\n customLogicOptions.resources\r\n );\r\n } catch (error) {\r\n log(2, '[chart] The `resources` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.resources = null;\r\n }\r\n\r\n // Process the `customCode` option\r\n try {\r\n // Try to load custom code and wrap around it in a self invoking function\r\n customLogicOptions.customCode = _handleCustomCode(\r\n customLogicOptions.customCode,\r\n customLogicOptions.allowFileResources\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.customCode = validateOption(\r\n 'customCode',\r\n customLogicOptions.customCode\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `customCode` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.customCode = null;\r\n }\r\n\r\n // Process the `callback` option\r\n try {\r\n // Try to load callback function\r\n customLogicOptions.callback = _handleCustomCode(\r\n customLogicOptions.callback,\r\n customLogicOptions.allowFileResources,\r\n true\r\n );\r\n\r\n // Validate the option\r\n customLogicOptions.callback = validateOption(\r\n 'callback',\r\n customLogicOptions.callback\r\n );\r\n } catch (error) {\r\n logWithStack(2, error, '[chart] The `callback` cannot be loaded.');\r\n\r\n // In case of an error, set the option with null\r\n customLogicOptions.callback = null;\r\n }\r\n\r\n // Check if there is the `customCode` present\r\n if ([null, undefined].includes(customLogicOptions.customCode)) {\r\n log(3, '[chart] No value for the `customCode` option found.');\r\n }\r\n\r\n // Check if there is the `callback` present\r\n if ([null, undefined].includes(customLogicOptions.callback)) {\r\n log(3, '[chart] No value for the `callback` option found.');\r\n }\r\n\r\n // Check if there is the `resources` present\r\n if ([null, undefined].includes(customLogicOptions.resources)) {\r\n log(3, '[chart] No value for the `resources` option found.');\r\n }\r\n } else {\r\n // If the `allowCodeExecution` flag is set to false, we should refuse\r\n // the usage of the `callback`, `resources`, and `customCode` options.\r\n // Additionally, the worker will refuse to run arbitrary JavaScript.\r\n if (\r\n customLogicOptions.callback ||\r\n customLogicOptions.resources ||\r\n customLogicOptions.customCode\r\n ) {\r\n // Reset all custom code options\r\n customLogicOptions.callback = null;\r\n customLogicOptions.resources = null;\r\n customLogicOptions.customCode = null;\r\n\r\n // Send a message saying that the exporter does not support these settings\r\n throw new ExportError(\r\n `[chart] The 'callback', 'resources', and 'customCode' options have been disabled for this server.`,\r\n 403\r\n );\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Handles and validates resources from the `resources` option for export.\r\n *\r\n * @function _handleResources\r\n *\r\n * @param {(Object|string|null)} [resources=null] - The resources to be handled.\r\n * Can be either a JSON object, stringified JSON, a path to a JSON file,\r\n * or null. The default value is `null`.\r\n * @param {boolean} allowFileResources - A flag indicating whether loading\r\n * resources from files is allowed.\r\n * @param {boolean} allowCodeExecution - A flag indicating whether code\r\n * execution is allowed.\r\n *\r\n * @returns {(Object|null)} The handled resources or null if no valid resources\r\n * are found.\r\n */\r\nfunction _handleResources(\r\n resources = null,\r\n allowFileResources,\r\n allowCodeExecution\r\n) {\r\n let handledResources = resources;\r\n\r\n // If no resources found, try to load the default resources\r\n if (!handledResources) {\r\n resources = 'resources.json';\r\n }\r\n\r\n // List of allowed sections in the resources JSON\r\n const allowedProps = ['js', 'css', 'files'];\r\n\r\n // A flag that decides based to return resources or `null`\r\n let correctResources = false;\r\n\r\n // Try to load resources from a file\r\n if (\r\n allowFileResources &&\r\n typeof resources === 'string' &&\r\n resources.endsWith('.json')\r\n ) {\r\n handledResources = isAllowedConfig(\r\n readFileSync(getAbsolutePath(resources), 'utf8'),\r\n false,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Try to get JSON\r\n handledResources = isAllowedConfig(resources, false, allowCodeExecution);\r\n\r\n // Get rid of the files section\r\n if (handledResources && !allowFileResources) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Filter from unnecessary properties\r\n for (const propName in handledResources) {\r\n if (!allowedProps.includes(propName)) {\r\n delete handledResources[propName];\r\n } else if (!correctResources) {\r\n correctResources = true;\r\n }\r\n }\r\n\r\n // Check if at least one of allowed properties is present\r\n if (!correctResources) {\r\n return null;\r\n }\r\n\r\n // Handle files section\r\n if (handledResources.files) {\r\n handledResources.files = handledResources.files.map((item) => item.trim());\r\n if (!handledResources.files || handledResources.files.length <= 0) {\r\n delete handledResources.files;\r\n }\r\n }\r\n\r\n // Return resources\r\n return handledResources;\r\n}\r\n\r\n/**\r\n * Handles custom code to execute it safely.\r\n *\r\n * @function _handleCustomCode\r\n *\r\n * @param {string} customCode - The custom code to be wrapped.\r\n * @param {boolean} allowFileResources - Flag to allow loading code from a file.\r\n * @param {boolean} [isCallback=false] - Flag that indicates the returned code\r\n * must be in a callback format.\r\n *\r\n * @returns {(string|null)} The wrapped custom code or null if wrapping fails.\r\n */\r\nfunction _handleCustomCode(customCode, allowFileResources, isCallback = false) {\r\n if (customCode && typeof customCode === 'string') {\r\n customCode = customCode.trim();\r\n\r\n if (customCode.endsWith('.js')) {\r\n // Load a file if the file resources are allowed\r\n return allowFileResources\r\n ? _handleCustomCode(\r\n readFileSync(getAbsolutePath(customCode), 'utf8'),\r\n allowFileResources,\r\n isCallback\r\n )\r\n : null;\r\n } else if (\r\n !isCallback &&\r\n (customCode.startsWith('function()') ||\r\n customCode.startsWith('function ()') ||\r\n customCode.startsWith('()=>') ||\r\n customCode.startsWith('() =>'))\r\n ) {\r\n // Treat a function as a self-invoking expression\r\n return `(${customCode})()`;\r\n }\r\n\r\n // Or return as a stringified code\r\n return customCode.replace(/;$/, '');\r\n }\r\n}\r\n\r\n/**\r\n * Handles the loading and validation of the `globalOptions` and `themeOptions`\r\n * in the export options. If the option is a string and references a JSON file\r\n * (when the `allowFileResources` is `true`), it reads and parses the file.\r\n * Otherwise, it attempts to parse the string or object as JSON. If any errors\r\n * occur during this process, the option is set to `null`. If there is an error\r\n * loading or parsing the `globalOptions` or `themeOptions`, the error is logged\r\n * and the option is set to `null`.\r\n *\r\n * @function _handleGlobalAndTheme\r\n *\r\n * @param {Object} exportOptions - The configuration object containing `export`\r\n * options.\r\n * @param {Object} customLogicOptions - The configuration object containing\r\n * `customLogic` options.\r\n */\r\nfunction _handleGlobalAndTheme(exportOptions, customLogicOptions) {\r\n // Get the `allowFileResources` and `allowCodeExecution` flags\r\n const { allowFileResources, allowCodeExecution } = customLogicOptions;\r\n\r\n // Check the `globalOptions` and `themeOptions` options\r\n ['globalOptions', 'themeOptions'].forEach((optionsName) => {\r\n try {\r\n // Check if the option exists\r\n if (exportOptions[optionsName]) {\r\n // Check if it is a string and a file name with the `.json` extension\r\n if (\r\n allowFileResources &&\r\n typeof exportOptions[optionsName] === 'string' &&\r\n exportOptions[optionsName].endsWith('.json')\r\n ) {\r\n // Check if the file content can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n readFileSync(getAbsolutePath(exportOptions[optionsName]), 'utf8'),\r\n true,\r\n allowCodeExecution\r\n );\r\n } else {\r\n // Check if the value can be a config, and save it as a string\r\n exportOptions[optionsName] = isAllowedConfig(\r\n exportOptions[optionsName],\r\n true,\r\n allowCodeExecution\r\n );\r\n }\r\n\r\n // Validate the option\r\n exportOptions[optionsName] = validateOption(\r\n optionsName,\r\n exportOptions[optionsName]\r\n );\r\n }\r\n } catch (error) {\r\n logWithStack(\r\n 2,\r\n error,\r\n `[chart] The \\`${optionsName}\\` cannot be loaded.`\r\n );\r\n\r\n // In case of an error, set the option with null\r\n exportOptions[optionsName] = null;\r\n }\r\n });\r\n\r\n // Check if there is the `globalOptions` present\r\n if ([null, undefined].includes(exportOptions.globalOptions)) {\r\n log(3, '[chart] No value for the `globalOptions` option found.');\r\n }\r\n\r\n // Check if there is the `themeOptions` present\r\n if ([null, undefined].includes(exportOptions.themeOptions)) {\r\n log(3, '[chart] No value for the `themeOptions` option found.');\r\n }\r\n}\r\n\r\n/**\r\n * Validates the size of the data for the export process against a fixed limit\r\n * of 100MB.\r\n *\r\n * @function _checkDataSize\r\n *\r\n * @param {Object} imageOptions - The data object, which includes options from\r\n * the `export` and `customLogic` sections and will be sent to a Puppeteer page.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the size of the data for\r\n * the export process object exceeds the 100MB limit.\r\n */\r\nfunction _checkDataSize(imageOptions) {\r\n // Set the fixed data limit (100MB) for the dev-tools protocol\r\n const dataLimit = 100 * 1024 * 1024;\r\n\r\n // Get the size of the data\r\n const totalSize = Buffer.byteLength(JSON.stringify(imageOptions), 'utf-8');\r\n\r\n // Log the size in MB\r\n log(\r\n 3,\r\n `[chart] The current total size of the data for the export process is around ${(\r\n totalSize /\r\n (1024 * 1024)\r\n ).toFixed(2)}MB.`\r\n );\r\n\r\n // Check the size of data before passing to a page\r\n if (totalSize >= dataLimit) {\r\n throw new ExportError(\r\n `[chart] The data for the export process exceeds 100MB limit.`\r\n );\r\n }\r\n}\r\n\r\nexport default {\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n getAllowCodeExecution,\r\n setAllowCodeExecution\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This module provides utility functions for managing intervals\r\n * and timeouts in a centralized manner. It maintains a registry of all active\r\n * timers and allows for their efficient cleanup when needed to avoid potential\r\n * memory leaks, unintended behavior or a process from being stopped.\r\n */\r\n\r\nimport { log } from './logger.js';\r\n\r\n// Array that contains ids of all ongoing intervals and timeouts\r\nconst timerIds = [];\r\n\r\n/**\r\n * Adds id of the `setInterval` or `setTimeout` and to the `timerIds` array.\r\n *\r\n * @function addTimer\r\n *\r\n * @param {NodeJS.Timeout} id - Id of an interval or a timeout.\r\n */\r\nexport function addTimer(id) {\r\n timerIds.push(id);\r\n}\r\n\r\n/**\r\n * Clears all of ongoing intervals and timeouts by ids gathered\r\n * in the `timerIds` array.\r\n *\r\n * @function clearAllTimers\r\n */\r\nexport function clearAllTimers() {\r\n log(4, `[timer] Clearing all registered intervals and timeouts.`);\r\n for (const id of timerIds) {\r\n clearInterval(id);\r\n clearTimeout(id);\r\n }\r\n}\r\n\r\nexport default {\r\n addTimer,\r\n clearAllTimers\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for logging errors with stack traces\r\n * and handling error responses in an Express application.\r\n */\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { logWithStack } from '../../logger.js';\r\n\r\n/**\r\n * Middleware for logging errors with stack trace and handling error response.\r\n *\r\n * @function logErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function with\r\n * the passed error.\r\n */\r\nfunction logErrorMiddleware(error, request, response, next) {\r\n // Display the error with stack in a correct format\r\n logWithStack(1, error);\r\n\r\n // Delete the stack for the environment other than the development\r\n if (getOptions().other.nodeEnv !== 'development') {\r\n delete error.stack;\r\n }\r\n\r\n // Call the `returnErrorMiddleware` middleware\r\n return next(error);\r\n}\r\n\r\n/**\r\n * Middleware for returning error response.\r\n *\r\n * @function returnErrorMiddleware\r\n *\r\n * @param {Error} error - The error object.\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n */\r\nfunction returnErrorMiddleware(error, request, response, next) {\r\n // Gather all requied information for the response\r\n const { message, stack } = error;\r\n\r\n // Use the error's status code or the default 400\r\n const statusCode = error.statusCode || 400;\r\n\r\n // Set and return response\r\n response.status(statusCode).json({ statusCode, message, stack });\r\n}\r\n\r\n/**\r\n * Adds the error middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function errorMiddleware(app) {\r\n // Add log error middleware\r\n app.use(logErrorMiddleware);\r\n\r\n // Add set status and return error middleware\r\n app.use(returnErrorMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for configuring and enabling rate\r\n * limiting in an Express application.\r\n */\r\n\r\nimport rateLimit from 'express-rate-limit';\r\n\r\nimport { log } from '../../logger.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for enabling rate limiting on the specified Express app.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if could not configure and set\r\n * the rate limiting options.\r\n */\r\nexport default function rateLimitingMiddleware(app, rateLimitingOptions) {\r\n try {\r\n // Check if the rate limiting is enabled and the app exists\r\n if (app && rateLimitingOptions.enable) {\r\n const message =\r\n 'Too many requests, you have been rate limited. Please try again later.';\r\n\r\n // Options for the rate limiter\r\n const rateOptions = {\r\n window: rateLimitingOptions.window || 1,\r\n maxRequests: rateLimitingOptions.maxRequests || 30,\r\n delay: rateLimitingOptions.delay || 0,\r\n trustProxy: rateLimitingOptions.trustProxy || false,\r\n skipKey: rateLimitingOptions.skipKey || null,\r\n skipToken: rateLimitingOptions.skipToken || null\r\n };\r\n\r\n // Set if behind a proxy\r\n if (rateOptions.trustProxy) {\r\n app.enable('trust proxy');\r\n }\r\n\r\n // Create a limiter\r\n const limiter = rateLimit({\r\n // Time frame for which requests are checked and remembered\r\n windowMs: rateOptions.window * 60 * 1000,\r\n // Limit each IP to 100 requests per `windowMs`\r\n limit: rateOptions.maxRequests,\r\n // Disable delaying, full speed until the max limit is reached\r\n delayMs: rateOptions.delay,\r\n handler: (request, response) => {\r\n response.format({\r\n json: () => {\r\n response.status(429).send({ message });\r\n },\r\n default: () => {\r\n response.status(429).send(message);\r\n }\r\n });\r\n },\r\n skip: (request) => {\r\n // Allow bypassing the limiter if a valid key/token has been sent\r\n if (\r\n rateOptions.skipKey !== null &&\r\n rateOptions.skipToken !== null &&\r\n request.query.key === rateOptions.skipKey &&\r\n request.query.access_token === rateOptions.skipToken\r\n ) {\r\n log(4, '[rate limiting] Skipping rate limiter.');\r\n return true;\r\n }\r\n return false;\r\n }\r\n });\r\n\r\n // Use a limiter as a middleware\r\n app.use(limiter);\r\n\r\n log(\r\n 3,\r\n `[rate limiting] Enabled rate limiting with ${rateOptions.maxRequests} requests per ${rateOptions.window} minute for each IP, trusting proxy: ${rateOptions.trustProxy}.`\r\n );\r\n }\r\n } catch (error) {\r\n throw new ExportError(\r\n '[rate limiting] Could not configure and set the rate limiting options.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Provides middleware functions for validating incoming HTTP requests\r\n * in an Express application. This module ensures that requests contain\r\n * appropriate content types and valid request bodies, including proper JSON\r\n * structures and chart data for exports. It checks for potential issues such\r\n * as missing or malformed data, private range URLs in SVG payloads, and allows\r\n * for flexible options validation. The middleware logs detailed information\r\n * and handles errors related to incorrect payloads, chart data, and private URL\r\n * usage.\r\n */\r\n\r\nimport { v4 as uuid } from 'uuid';\r\n\r\nimport { getAllowCodeExecution } from '../../chart.js';\r\nimport { isAllowedConfig } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { isObjectEmpty, isPrivateRangeUrlFound } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Middleware for validating the content-type header.\r\n *\r\n * @function contentTypeMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the content-type\r\n * is not correct.\r\n */\r\nfunction contentTypeMiddleware(request, response, next) {\r\n try {\r\n // Get the content type header\r\n const contentType = request.headers['content-type'] || '';\r\n\r\n // Allow only JSON, URL-encoded and form data without files types of data\r\n if (\r\n !contentType.includes('application/json') &&\r\n !contentType.includes('application/x-www-form-urlencoded') &&\r\n !contentType.includes('multipart/form-data')\r\n ) {\r\n throw new ExportError(\r\n '[validation] Content-Type must be application/json, application/x-www-form-urlencoded, or multipart/form-data.',\r\n 415\r\n );\r\n }\r\n\r\n // Call the `requestBodyMiddleware` middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Middleware for validating the request's body.\r\n *\r\n * @function requestBodyMiddleware\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {undefined} The call to the next middleware function.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the body is not correct.\r\n * @throws {ExportError} Throws an `ExportError` if the chart data from the body\r\n * is not correct.\r\n * @throws {ExportError} Throws an `ExportError` in case of the private range\r\n * url error.\r\n */\r\nfunction requestBodyMiddleware(request, response, next) {\r\n try {\r\n // Get the request body\r\n const body = request.body;\r\n\r\n // Create a unique ID for a request\r\n const requestId = uuid();\r\n\r\n // Throw an error if there is no correct body\r\n if (!body || isObjectEmpty(body)) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is empty.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - The request body is required. Please ensure that your Content-Type header is correct. Accepted types are 'application/json' and 'multipart/form-data'.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get the `allowCodeExecution` option for the server\r\n const allowCodeExecution = getAllowCodeExecution();\r\n\r\n // Find a correct chart options\r\n const instr = isAllowedConfig(\r\n // Use one of the below\r\n body.instr || body.options || body.infile || body.data,\r\n // Stringify options\r\n true,\r\n // Allow or disallow functions\r\n allowCodeExecution\r\n );\r\n\r\n // Throw an error if there is no correct chart data\r\n if (instr === null && !body.svg) {\r\n log(\r\n 2,\r\n `[validation] Request [${requestId}] - The request from ${\r\n request.headers['x-forwarded-for'] || request.connection.remoteAddress\r\n } was incorrect. Received payload is missing correct chart data for export: ${JSON.stringify(body)}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - No correct chart data found. Ensure that you are using either application/json or multipart/form-data headers. If sending JSON, make sure the chart data is in the 'infile', 'options', or 'data' attribute. If sending SVG, ensure it is in the 'svg' attribute.`,\r\n 400\r\n );\r\n }\r\n\r\n // Throw an error if test of xlink:href elements from payload's SVG fails\r\n if (body.svg && isPrivateRangeUrlFound(body.svg)) {\r\n throw new ExportError(\r\n `[validation] Request [${requestId}] - SVG potentially contain at least one forbidden URL in 'xlink:href' element. Please review the SVG content and ensure that all referenced URLs comply with security policies.`,\r\n 400\r\n );\r\n }\r\n\r\n // Get and pre-validate the options and store them in the request\r\n request.validatedOptions = {\r\n // Set the created ID as a `requestId` property in the options\r\n requestId,\r\n export: {\r\n instr,\r\n svg: body.svg,\r\n outfile:\r\n body.outfile ||\r\n `${request.params.filename || 'chart'}.${body.type || 'png'}`,\r\n type: body.type,\r\n constr: body.constr,\r\n b64: body.b64,\r\n noDownload: body.noDownload,\r\n height: body.height,\r\n width: body.width,\r\n scale: body.scale,\r\n globalOptions: isAllowedConfig(\r\n body.globalOptions,\r\n true,\r\n allowCodeExecution\r\n ),\r\n themeOptions: isAllowedConfig(\r\n body.themeOptions,\r\n true,\r\n allowCodeExecution\r\n )\r\n },\r\n customLogic: {\r\n allowCodeExecution,\r\n allowFileResources: false,\r\n customCode: body.customCode,\r\n callback: body.callback,\r\n resources: isAllowedConfig(body.resources, true, allowCodeExecution)\r\n }\r\n };\r\n\r\n // Call the next middleware\r\n return next();\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the validation middlewares to the passed express app instance.\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function validationMiddleware(app) {\r\n // Add content type validation middleware\r\n app.post(['/', '/:filename'], contentTypeMiddleware);\r\n\r\n // Add request body request validation middleware\r\n app.post(['/', '/:filename'], requestBodyMiddleware);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines the export routes and logic for handling chart export\r\n * requests in an Express server. This module processes incoming requests\r\n * to export charts in various formats (e.g. JPEG, PNG, PDF, SVG). It integrates\r\n * with Highcharts' core functionalities and supports both immediate download\r\n * responses and Base64-encoded content returns. The code also features\r\n * benchmarking for performance monitoring.\r\n */\r\n\r\nimport { startExport } from '../../chart.js';\r\nimport { log } from '../../logger.js';\r\nimport { getBase64, measureTime } from '../../utils.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n// Reversed MIME types\r\nconst reversedMime = {\r\n png: 'image/png',\r\n jpeg: 'image/jpeg',\r\n gif: 'image/gif',\r\n pdf: 'application/pdf',\r\n svg: 'image/svg+xml'\r\n};\r\n\r\n/**\r\n * Handles the export requests from the client.\r\n *\r\n * @async\r\n * @function requestExport\r\n *\r\n * @param {Express.Request} request - The Express request object.\r\n * @param {Express.Response} response - The Express response object.\r\n * @param {Function} next - The next middleware function.\r\n *\r\n * @returns {Promise} A Promise that resolves once the export process\r\n * is complete.\r\n */\r\nasync function requestExport(request, response, next) {\r\n try {\r\n // Start counting time for a request\r\n const requestCounter = measureTime();\r\n\r\n // In case the connection is closed, force to abort further actions\r\n let connectionAborted = false;\r\n request.socket.on('close', (hadErrors) => {\r\n if (hadErrors) {\r\n connectionAborted = true;\r\n }\r\n });\r\n\r\n // Get the options previously validated in the validation middleware\r\n const options = request.validatedOptions;\r\n\r\n // Get the request id\r\n const requestId = options.requestId;\r\n\r\n // Info about an incoming request with correct data\r\n log(4, `[export] Request [${requestId}] - Got an incoming HTTP request.`);\r\n\r\n // Start the export process\r\n await startExport(options, (error, data) => {\r\n // Remove the close event from the socket\r\n request.socket.removeAllListeners('close');\r\n\r\n // If the connection was closed, do nothing\r\n if (connectionAborted) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The client closed the connection before the chart finished processing.`\r\n );\r\n return;\r\n }\r\n\r\n // If error, log it and send it to the error middleware\r\n if (error) {\r\n throw error;\r\n }\r\n\r\n // If data is missing, log the message and send it to the error middleware\r\n if (!data || !data.result) {\r\n log(\r\n 2,\r\n `[export] Request [${requestId}] - Request from ${\r\n request.headers['x-forwarded-for'] ||\r\n request.connection.remoteAddress\r\n } was incorrect. Received result is ${data.result}.`\r\n );\r\n\r\n throw new ExportError(\r\n `[export] Request [${requestId}] - Unexpected return of the export result from the chart generation. Please check your request data.`,\r\n 400\r\n );\r\n }\r\n\r\n // Return the result in an appropriate format\r\n if (data.result) {\r\n log(\r\n 3,\r\n `[export] Request [${requestId}] - The whole exporting process took ${requestCounter()}ms.`\r\n );\r\n\r\n // Get the `type`, `b64`, `noDownload`, and `outfile` from options\r\n const { type, b64, noDownload, outfile } = data.options.export;\r\n\r\n // If only Base64 is required, return it\r\n if (b64) {\r\n return response.send(getBase64(data.result, type));\r\n }\r\n\r\n // Set correct content type\r\n response.header('Content-Type', reversedMime[type] || 'image/png');\r\n\r\n // Decide whether to download or not chart file\r\n if (!noDownload) {\r\n response.attachment(outfile);\r\n }\r\n\r\n // If SVG, return plain content, otherwise a b64 string from a buffer\r\n return type === 'svg'\r\n ? response.send(data.result)\r\n : response.send(Buffer.from(data.result, 'base64'));\r\n }\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n}\r\n\r\n/**\r\n * Adds the `export` routes.\r\n *\r\n * @function exportRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function exportRoutes(app) {\r\n /**\r\n * Adds the POST '/' - A route for handling POST requests at the root\r\n * endpoint.\r\n */\r\n app.post('/', requestExport);\r\n\r\n /**\r\n * Adds the POST '/:filename' - A route for handling POST requests with\r\n * a specified filename parameter.\r\n */\r\n app.post('/:filename', requestExport);\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for server health monitoring, including\r\n * uptime, success rates, and other server statistics.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport { getHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { getPoolInfoJSON, getPoolStats } from '../../pool.js';\r\nimport { addTimer } from '../../timer.js';\r\nimport { __dirname, getNewDateTime } from '../../utils.js';\r\n\r\n// Set the start date of the server\r\nconst serverStartTime = new Date();\r\n\r\n// Get the `package.json` content\r\nconst packageFile = JSON.parse(\r\n readFileSync(join(__dirname, 'package.json'), 'utf8')\r\n);\r\n\r\n// An array for success rate ratios\r\nconst successRates = [];\r\n\r\n// Record every minute\r\nconst recordInterval = 60 * 1000;\r\n\r\n// 30 minutes\r\nconst windowSize = 30;\r\n\r\n/**\r\n * Calculates moving average indicator based on the data from the `successRates`\r\n * array.\r\n *\r\n * @function _calculateMovingAverage\r\n *\r\n * @returns {number} A moving average for success ratio of the server exports.\r\n */\r\nfunction _calculateMovingAverage() {\r\n return successRates.reduce((a, b) => a + b, 0) / successRates.length;\r\n}\r\n\r\n/**\r\n * Starts the interval responsible for calculating current success rate ratio\r\n * and collects records to the `successRates` array.\r\n *\r\n * @function _startSuccessRate\r\n *\r\n * @returns {NodeJS.Timeout} Id of an interval.\r\n */\r\nfunction _startSuccessRate() {\r\n return setInterval(() => {\r\n const stats = getPoolStats();\r\n const successRatio =\r\n stats.exportsAttempted === 0\r\n ? 1\r\n : (stats.exportsPerformed / stats.exportsAttempted) * 100;\r\n\r\n successRates.push(successRatio);\r\n if (successRates.length > windowSize) {\r\n successRates.shift();\r\n }\r\n }, recordInterval);\r\n}\r\n\r\n/**\r\n * Adds the `health` routes.\r\n *\r\n * @function healthRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function healthRoutes(app) {\r\n // Start processing success rate ratio interval and save its id to the array\r\n // for the graceful clearing on shutdown with injected `addTimer` funtion\r\n addTimer(_startSuccessRate());\r\n\r\n /**\r\n * Adds the GET '/health' - A route for getting the basic stats of the server.\r\n */\r\n app.get('/health', (request, response, next) => {\r\n try {\r\n log(4, '[health] Returning server health.');\r\n\r\n const stats = getPoolStats();\r\n const period = successRates.length;\r\n const movingAverage = _calculateMovingAverage();\r\n\r\n // Send the server's statistics\r\n response.send({\r\n // Status and times\r\n status: 'OK',\r\n bootTime: serverStartTime,\r\n uptime: `${Math.floor((getNewDateTime() - serverStartTime.getTime()) / 1000 / 60)} minutes`,\r\n\r\n // Versions\r\n serverVersion: packageFile.version,\r\n highchartsVersion: getHcVersion(),\r\n\r\n // Exports\r\n averageExportTime: stats.timeSpentAverage,\r\n attemptedExports: stats.exportsAttempted,\r\n performedExports: stats.exportsPerformed,\r\n failedExports: stats.exportsDropped,\r\n sucessRatio: (stats.exportsPerformed / stats.exportsAttempted) * 100,\r\n\r\n // Pool\r\n pool: getPoolInfoJSON(),\r\n\r\n // Moving average\r\n period,\r\n movingAverage,\r\n message:\r\n isNaN(movingAverage) || !successRates.length\r\n ? 'Too early to report. No exports made yet. Please check back soon.'\r\n : `Last ${period} minutes had a success rate of ${movingAverage.toFixed(2)}%.`,\r\n\r\n // SVG and JSON exports\r\n svgExports: stats.exportsFromSvg,\r\n jsonExports: stats.exportsFromOptions,\r\n svgExportsAttempts: stats.exportsFromSvgAttempts,\r\n jsonExportsAttempts: stats.exportsFromOptionsAttempts\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for serving the UI for the export server\r\n * when enabled.\r\n */\r\n\r\nimport { join } from 'path';\r\n\r\nimport { getOptions } from '../../config.js';\r\nimport { log } from '../../logger.js';\r\nimport { __dirname } from '../../utils.js';\r\n\r\n/**\r\n * Adds the `ui` routes.\r\n *\r\n * @function uiRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function uiRoutes(app) {\r\n // Add the UI endpoint only if required\r\n if (getOptions().ui.enable) {\r\n /**\r\n * Adds the GET '/' - A route for a UI when enabled on the export server.\r\n */\r\n app.get(getOptions().ui.route || '/', (request, response, next) => {\r\n try {\r\n log(4, '[ui] Returning UI for the export.');\r\n\r\n response.sendFile(join(__dirname, 'public', 'index.html'), {\r\n acceptRanges: false\r\n });\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n }\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Defines an Express route for updating the Highcharts version\r\n * on the server, with authentication and validation.\r\n */\r\n\r\nimport { getHcVersion, updateHcVersion } from '../../cache.js';\r\nimport { log } from '../../logger.js';\r\nimport { envs } from '../../validation.js';\r\n\r\nimport ExportError from '../../errors/ExportError.js';\r\n\r\n/**\r\n * Adds the `version_change` routes.\r\n *\r\n * @function versionChangeRoutes\r\n *\r\n * @param {Express} app - The Express app instance.\r\n */\r\nexport default function versionChangeRoutes(app) {\r\n /**\r\n * Adds the POST '/version_change/:newVersion' - A route for changing\r\n * the Highcharts version on the server.\r\n */\r\n app.post('/version_change/:newVersion', async (request, response, next) => {\r\n try {\r\n log(4, '[version] Changing Highcharts version.');\r\n\r\n // Get the token directly from envs\r\n const adminToken = envs.HIGHCHARTS_ADMIN_TOKEN;\r\n\r\n // Check the existence of the token\r\n if (!adminToken || !adminToken.length) {\r\n throw new ExportError(\r\n '[version] The server is not configured to perform run-time version changes: `HIGHCHARTS_ADMIN_TOKEN` is not set.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the token from the hc-auth header\r\n const token = request.get('hc-auth');\r\n\r\n // Check if the hc-auth header contain a correct token\r\n if (!token || token !== adminToken) {\r\n throw new ExportError(\r\n '[version] Invalid or missing token: Set the token in the hc-auth header.',\r\n 401\r\n );\r\n }\r\n\r\n // Get the new version from the params\r\n const newVersion = request.params.newVersion;\r\n\r\n // Update version\r\n if (newVersion) {\r\n try {\r\n await updateHcVersion(newVersion);\r\n } catch (error) {\r\n throw new ExportError(\r\n `[version] Version change: ${error.message}`,\r\n 400\r\n ).setError(error);\r\n }\r\n\r\n // Success\r\n response.status(200).send({\r\n statusCode: 200,\r\n highchartsVersion: getHcVersion(),\r\n message: `Successfully updated Highcharts to version: ${newVersion}.`\r\n });\r\n } else {\r\n // No version specified\r\n throw new ExportError('[version] No new version supplied.', 400);\r\n }\r\n } catch (error) {\r\n return next(error);\r\n }\r\n });\r\n}\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview A module that sets up and manages HTTP and HTTPS servers\r\n * for the Highcharts Export Server. It handles server initialization,\r\n * configuration, error handling, middlewares setup, route definition, and rate\r\n * limiting. The module exports functions to start, stop, and manage server\r\n * instances, as well as utility functions for defining routes and attaching\r\n * middlewares.\r\n */\r\n\r\nimport { readFileSync } from 'fs';\r\nimport { join } from 'path';\r\n\r\nimport cors from 'cors';\r\nimport express from 'express';\r\nimport http from 'http';\r\nimport https from 'https';\r\nimport multer from 'multer';\r\n\r\nimport { updateOptions } from '../config.js';\r\nimport { log, logWithStack } from '../logger.js';\r\nimport { __dirname, getAbsolutePath } from '../utils.js';\r\n\r\nimport errorMiddleware from './middlewares/error.js';\r\nimport rateLimitingMiddleware from './middlewares/rateLimiting.js';\r\nimport validationMiddleware from './middlewares/validation.js';\r\n\r\nimport exportRoutes from './routes/export.js';\r\nimport healthRoutes from './routes/health.js';\r\nimport uiRoutes from './routes/ui.js';\r\nimport versionChangeRoutes from './routes/versionChange.js';\r\n\r\nimport ExportError from '../errors/ExportError.js';\r\n\r\n// Array of an active servers\r\nconst activeServers = new Map();\r\n\r\n// Create express app\r\nconst app = express();\r\n\r\n/**\r\n * Starts an HTTP and/or HTTPS server based on the provided configuration.\r\n * The `serverOptions` object contains server-related properties (refer\r\n * to the `server` section in the `./lib/schemas/config.js` file for details).\r\n *\r\n * @async\r\n * @function startServer\r\n *\r\n * @param {Object} [serverOptions={}] - The configuration object containing\r\n * `server` options. This object may include a partial or complete set\r\n * of the `server` options. If the options are partial, missing values will\r\n * default to the current global configuration. The default value is an empty\r\n * object.\r\n *\r\n * @returns {Promise} A Promise that resolves when the server is either\r\n * not enabled or no valid Express app is found, signaling the end of the\r\n * function's execution.\r\n *\r\n * @throws {ExportError} Throws an `ExportError` if the server cannot\r\n * be configured and started.\r\n */\r\nexport async function startServer(serverOptions = {}) {\r\n try {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: serverOptions\r\n });\r\n\r\n // Use validated options\r\n serverOptions = options.server;\r\n\r\n // Stop if not enabled\r\n if (!serverOptions.enable || !app) {\r\n throw new ExportError(\r\n '[server] Server cannot be started (not enabled or no correct Express app found).',\r\n 500\r\n );\r\n }\r\n\r\n // Too big limits lead to timeouts in the export process when\r\n // the rasterization timeout is set too low\r\n const uploadLimitBytes = serverOptions.uploadLimit * 1024 * 1024;\r\n\r\n // Memory storage for multer package\r\n const storage = multer.memoryStorage();\r\n\r\n // Enable parsing of form data (files) with multer package\r\n const upload = multer({\r\n storage,\r\n limits: {\r\n fieldSize: uploadLimitBytes\r\n }\r\n });\r\n\r\n // Disable the X-Powered-By header\r\n app.disable('x-powered-by');\r\n\r\n // Enable CORS support\r\n app.use(\r\n cors({\r\n methods: ['POST', 'GET', 'OPTIONS']\r\n })\r\n );\r\n\r\n // Getting a lot of `RangeNotSatisfiableError` exceptions (even though this\r\n // is a deprecated options, let's try to set it to false)\r\n app.use((request, response, next) => {\r\n response.set('Accept-Ranges', 'none');\r\n next();\r\n });\r\n\r\n // Enable body parser for JSON data\r\n app.use(\r\n express.json({\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Enable body parser for URL-encoded form data\r\n app.use(\r\n express.urlencoded({\r\n extended: true,\r\n limit: uploadLimitBytes\r\n })\r\n );\r\n\r\n // Use only non-file multipart form fields\r\n app.use(upload.none());\r\n\r\n // Set up static folder's route\r\n app.use(express.static(join(__dirname, 'public')));\r\n\r\n // Listen HTTP server\r\n if (!serverOptions.ssl.force) {\r\n // Main server instance (HTTP)\r\n const httpServer = http.createServer(app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpServer);\r\n\r\n // Listen\r\n httpServer.listen(serverOptions.port, serverOptions.host, () => {\r\n // Save the reference to HTTP server\r\n activeServers.set(serverOptions.port, httpServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTP server on ${serverOptions.host}:${serverOptions.port}.`\r\n );\r\n });\r\n }\r\n\r\n // Listen HTTPS server\r\n if (serverOptions.ssl.enable) {\r\n // Set up an SSL server also\r\n let key, cert;\r\n\r\n try {\r\n // Get the SSL key\r\n key = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.key'),\r\n 'utf8'\r\n );\r\n\r\n // Get the SSL certificate\r\n cert = readFileSync(\r\n join(getAbsolutePath(serverOptions.ssl.certPath), 'server.crt'),\r\n 'utf8'\r\n );\r\n } catch (error) {\r\n log(\r\n 2,\r\n `[server] Unable to load key/certificate from the '${serverOptions.ssl.certPath}' path. Could not run secured layer server.`\r\n );\r\n }\r\n\r\n if (key && cert) {\r\n // Main server instance (HTTPS)\r\n const httpsServer = https.createServer({ key, cert }, app);\r\n\r\n // Attach error handlers and listen to the server\r\n _attachServerErrorHandlers(httpsServer);\r\n\r\n // Listen\r\n httpsServer.listen(serverOptions.ssl.port, serverOptions.host, () => {\r\n // Save the reference to HTTPS server\r\n activeServers.set(serverOptions.ssl.port, httpsServer);\r\n\r\n log(\r\n 3,\r\n `[server] Started HTTPS server on ${serverOptions.host}:${serverOptions.ssl.port}.`\r\n );\r\n });\r\n }\r\n }\r\n\r\n // Set up the rate limiter\r\n rateLimitingMiddleware(app, serverOptions.rateLimiting);\r\n\r\n // Set up the validation handler\r\n validationMiddleware(app);\r\n\r\n // Set up routes\r\n exportRoutes(app);\r\n healthRoutes(app);\r\n uiRoutes(app);\r\n versionChangeRoutes(app);\r\n\r\n // Set up the centralized error handler\r\n errorMiddleware(app);\r\n } catch (error) {\r\n throw new ExportError(\r\n '[server] Could not configure and start the server.',\r\n 500\r\n ).setError(error);\r\n }\r\n}\r\n\r\n/**\r\n * Closes all servers associated with Express app instance.\r\n *\r\n * @function closeServers\r\n */\r\nexport function closeServers() {\r\n // Check if there are servers working\r\n if (activeServers.size > 0) {\r\n log(4, `[server] Closing all servers.`);\r\n\r\n // Close each one of servers\r\n for (const [port, server] of activeServers) {\r\n server.close(() => {\r\n activeServers.delete(port);\r\n log(4, `[server] Closed server on port: ${port}.`);\r\n });\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * Get all servers associated with Express app instance.\r\n *\r\n * @function getServers\r\n *\r\n * @returns {Array} Servers associated with Express app instance.\r\n */\r\nexport function getServers() {\r\n return activeServers;\r\n}\r\n\r\n/**\r\n * Get the Express instance.\r\n *\r\n * @function getExpress\r\n *\r\n * @returns {Express} The Express instance.\r\n */\r\nexport function getExpress() {\r\n return express;\r\n}\r\n\r\n/**\r\n * Get the Express app instance.\r\n *\r\n * @function getApp\r\n *\r\n * @returns {Express} The Express app instance.\r\n */\r\nexport function getApp() {\r\n return app;\r\n}\r\n\r\n/**\r\n * Enable rate limiting for the server.\r\n *\r\n * @function enableRateLimiting\r\n *\r\n * @param {Object} rateLimitingOptions - The configuration object containing\r\n * `rateLimiting` options. This object may include a partial or complete set\r\n * of the `rateLimiting` options. If the options are partial, missing values\r\n * will default to the current global configuration.\r\n */\r\nexport function enableRateLimiting(rateLimitingOptions) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n server: {\r\n rateLimiting: rateLimitingOptions\r\n }\r\n });\r\n\r\n // Set the rate limiting options\r\n rateLimitingMiddleware(app, options.server.rateLimitingOptions);\r\n}\r\n\r\n/**\r\n * Apply middleware(s) to a specific path.\r\n *\r\n * @function use\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function use(path, ...middlewares) {\r\n app.use(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with GET method and apply middleware(s).\r\n *\r\n * @function get\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function get(path, ...middlewares) {\r\n app.get(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Set up a route with POST method and apply middleware(s).\r\n *\r\n * @function post\r\n *\r\n * @param {string} path - The path to which the middleware(s) should be applied.\r\n * @param {...Function} middlewares - The middleware function(s) to be applied.\r\n */\r\nexport function post(path, ...middlewares) {\r\n app.post(path, ...middlewares);\r\n}\r\n\r\n/**\r\n * Attach error handlers to the server.\r\n *\r\n * @function _attachServerErrorHandlers\r\n *\r\n * @param {(http.Server|https.Server)} server - The HTTP/HTTPS server instance.\r\n */\r\nfunction _attachServerErrorHandlers(server) {\r\n server.on('clientError', (error, socket) => {\r\n logWithStack(\r\n 1,\r\n error,\r\n `[server] Client error: ${error.message}, destroying socket.`\r\n );\r\n socket.destroy();\r\n });\r\n\r\n server.on('error', (error) => {\r\n logWithStack(1, error, `[server] Server error: ${error.message}`);\r\n });\r\n\r\n server.on('connection', (socket) => {\r\n socket.on('error', (error) => {\r\n logWithStack(1, error, `[server] Socket error: ${error.message}`);\r\n });\r\n });\r\n}\r\n\r\nexport default {\r\n startServer,\r\n closeServers,\r\n getServers,\r\n getExpress,\r\n getApp,\r\n enableRateLimiting,\r\n use,\r\n get,\r\n post\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview Handles graceful shutdown of the Highcharts Export Server, ensuring\r\n * proper cleanup of resources such as browser, pages, servers, and timers.\r\n */\r\n\r\nimport { killPool } from './pool.js';\r\nimport { clearAllTimers } from './timer.js';\r\n\r\nimport { closeServers } from './server/server.js';\r\n\r\n/**\r\n * Performs cleanup operations to ensure a graceful shutdown of the process.\r\n * This includes clearing all registered timeouts/intervals, closing active\r\n * servers, terminating resources (pages) of the pool, pool itself, and closing\r\n * the browser.\r\n *\r\n * @function shutdownCleanUp\r\n *\r\n * @param {number} [exitCode=0] - The exit code to use with `process.exit()`.\r\n * The default value is `0`.\r\n */\r\nexport async function shutdownCleanUp(exitCode = 0) {\r\n // Await freeing all resources\r\n await Promise.allSettled([\r\n // Clear all ongoing intervals\r\n clearAllTimers(),\r\n\r\n // Get available server instances (HTTP/HTTPS) and close them\r\n closeServers(),\r\n\r\n // Close an active pool along with its workers and the browser instance\r\n killPool()\r\n ]);\r\n\r\n // Exit process with a correct code\r\n process.exit(exitCode);\r\n}\r\n\r\nexport default {\r\n shutdownCleanUp\r\n};\r\n","/*******************************************************************************\r\n\r\nHighcharts Export Server\r\n\r\nCopyright (c) 2016-2025, Highsoft\r\n\r\nLicenced under the MIT licence.\r\n\r\nAdditionally a valid Highcharts license is required for use.\r\n\r\nSee LICENSE file in root for details.\r\n\r\n*******************************************************************************/\r\n\r\n/**\r\n * @overview This core module initializes and manages the Highcharts Export\r\n * Server. The main `initExport` function handles logging, script caching,\r\n * resource pooling, browser startup, and ensures graceful process cleanup\r\n * on exit. Additionally, it provides API functions for using it as a Node.js\r\n * module, offering functionalities for processing options, configuring\r\n * and performing exports, and setting up server.\r\n */\r\n\r\nimport 'colors';\r\n\r\nimport { checkCache } from './cache.js';\r\nimport {\r\n batchExport,\r\n singleExport,\r\n startExport,\r\n setAllowCodeExecution\r\n} from './chart.js';\r\nimport {\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n validateOption,\r\n validateOptions\r\n} from './config.js';\r\nimport {\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n initLogging,\r\n enableConsoleLogging,\r\n enableFileLogging,\r\n setLogLevel\r\n} from './logger.js';\r\nimport { initPool, killPool } from './pool.js';\r\nimport { shutdownCleanUp } from './resourceRelease.js';\r\n\r\nimport server from './server/server.js';\r\n\r\n/**\r\n * Initializes the export process. Tasks such as configuring logging, checking\r\n * the cache and sources, and initializing the resource pool occur during this\r\n * stage.\r\n *\r\n * This function must be called before attempting to export charts or set\r\n * up a server.\r\n *\r\n * @async\r\n * @function initExport\r\n *\r\n * @param {Object} [initOptions={}] - The `initOptions` object, which may\r\n * be a partial or complete set of options. If the options are partial, missing\r\n * values will default to the current global configuration. The default value\r\n * is an empty object.\r\n */\r\nexport async function initExport(initOptions = {}) {\r\n // Init, validate and update the options object\r\n const options = updateOptions(initOptions);\r\n\r\n // Set the `allowCodeExecution` per export module scope\r\n setAllowCodeExecution(options.customLogic.allowCodeExecution);\r\n\r\n // Init the logging\r\n initLogging(options.logging);\r\n\r\n // Attach process' exit listeners\r\n if (options.other.listenToProcessExits) {\r\n _attachProcessExitListeners();\r\n }\r\n\r\n // Check the current status of cache\r\n await checkCache(options.highcharts, options.server.proxy);\r\n\r\n // Init the pool\r\n await initPool(options.pool, options.puppeteer.args);\r\n}\r\n\r\n/**\r\n * Attaches exit listeners to the process, ensuring proper cleanup of resources\r\n * and termination on exit signals. Handles 'exit', 'SIGINT', 'SIGTERM',\r\n * and 'uncaughtException' events.\r\n *\r\n * @function _attachProcessExitListeners\r\n */\r\nfunction _attachProcessExitListeners() {\r\n log(3, '[process] Attaching exit listeners to the process.');\r\n\r\n // Handler for the 'exit'\r\n process.on('exit', (code) => {\r\n log(4, `[process] Process exited with code: ${code}.`);\r\n });\r\n\r\n // Handler for the 'SIGINT'\r\n process.on('SIGINT', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGTERM'\r\n process.on('SIGTERM', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'SIGHUP'\r\n process.on('SIGHUP', async (name, code) => {\r\n log(4, `[process] The ${name} event with code: ${code}.`);\r\n await shutdownCleanUp();\r\n });\r\n\r\n // Handler for the 'uncaughtException'\r\n process.on('uncaughtException', async (error, name) => {\r\n logWithStack(1, error, `[process] The ${name} error.`);\r\n await shutdownCleanUp(1);\r\n });\r\n}\r\n\r\nexport default {\r\n // Server\r\n ...server,\r\n\r\n // Options\r\n getOptions,\r\n updateOptions,\r\n mapToNewOptions,\r\n\r\n // Validation\r\n validateOption,\r\n validateOptions,\r\n\r\n // Exporting\r\n initExport,\r\n singleExport,\r\n batchExport,\r\n startExport,\r\n\r\n // Release\r\n killPool,\r\n shutdownCleanUp,\r\n\r\n // Logs\r\n log,\r\n logWithStack,\r\n logZodIssues,\r\n setLogLevel: function (level) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n level\r\n }\r\n });\r\n\r\n // Call the function\r\n setLogLevel(options.logging.level);\r\n },\r\n enableConsoleLogging: function (toConsole) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n toConsole\r\n }\r\n });\r\n\r\n // Call the function\r\n enableConsoleLogging(options.logging.toConsole);\r\n },\r\n enableFileLogging: function (dest, file, toFile) {\r\n // Update the instance options object\r\n const options = updateOptions({\r\n logging: {\r\n dest,\r\n file,\r\n toFile\r\n }\r\n });\r\n\r\n // Call the function\r\n enableFileLogging(\r\n options.logging.dest,\r\n options.logging.file,\r\n options.logging.toFile\r\n );\r\n }\r\n};\r\n"],"names":["__dirname","fileURLToPath","URL","url","deepCopy","objArr","objArrCopy","Array","isArray","key","Object","prototype","hasOwnProperty","call","getAbsolutePath","path","isAbsolute","normalize","resolve","getBase64","input","type","Buffer","from","toString","getNewDate","Date","split","trim","getNewDateTime","getTime","isObject","item","isObjectEmpty","keys","length","isPrivateRangeUrlFound","some","pattern","test","measureTime","start","process","hrtime","bigint","Number","roundNumber","value","precision","multiplier","Math","pow","round","colors","logging","toConsole","toFile","pathCreated","pathToLog","levelsDesc","title","color","log","args","newLevel","texts","level","prefix","_logToFile","console","apply","undefined","concat","logWithStack","error","customMessage","mainMessage","message","stackMessage","stack","push","shift","logZodIssues","issues","map","issue","join","initLogging","loggingOptions","dest","file","setLogLevel","enableConsoleLogging","enableFileLogging","isInteger","existsSync","mkdirSync","appendFile","defaultConfig","puppeteer","types","envLink","cliName","description","promptOptions","separator","highcharts","version","cdnUrl","forceFetch","cachePath","coreScripts","instructions","moduleScripts","indicatorScripts","customScripts","export","infile","instr","options","svg","batch","outfile","hint","choices","constr","b64","noDownload","height","width","scale","defaultHeight","defaultWidth","defaultScale","min","max","globalOptions","themeOptions","rasterizationTimeout","customLogic","allowCodeExecution","allowFileResources","customCode","callback","resources","loadConfig","legacyName","createConfig","server","enable","host","port","uploadLimit","benchmarking","proxy","timeout","rateLimiting","maxRequests","window","delay","trustProxy","skipKey","skipToken","ssl","force","certPath","pool","minWorkers","maxWorkers","workLimit","acquireTimeout","createTimeout","destroyTimeout","idleTimeout","createRetryInterval","reaperInterval","ui","route","other","nodeEnv","listenToProcessExits","noLogo","hardResetPage","browserShellMode","validation","debug","headless","devtools","listenToConsole","dumpio","slowMo","debuggingPort","dotenv","config","z","setErrorMap","_customErrorMap","v","boolean","strictCheck","union","enum","transform","includes","nullable","string","refine","params","errorMessage","values","stringArray","filterCallback","arraySchema","array","stringSchema","startsWith","slice","endsWith","transformCallback","filter","positiveNum","number","positive","isNaN","nonNegativeNum","nonnegative","prefixes","chartConfig","object","passthrough","additionalOptions","validators","adminToken","indexOf","gte","lte","this","objectSchema","js","css","files","partial","stringSchema1","stringSchema2","enableServer","serverBenchmarking","proxyHost","proxyPort","proxyTimeout","enableRateLimiting","enableSsl","sslForce","sslPort","sslCertPath","poolBenchmarking","resourcesInterval","logLevel","int","logFile","logDest","logToConsole","logToFile","enableUi","uiRoute","enableDebug","requestId","uuid","PuppeteerSchema","HighchartsSchema","ExportSchema","CustomLogicSchema","ProxySchema","RateLimitingSchema","SslSchema","ServerSchema","optional","PoolSchema","LoggingSchema","UiSchema","OtherSchema","DebugSchema","StrictConfigSchema","LooseConfigSchema","EnvSchema","PUPPETEER_ARGS","HIGHCHARTS_VERSION","HIGHCHARTS_CDN_URL","HIGHCHARTS_FORCE_FETCH","HIGHCHARTS_CACHE_PATH","HIGHCHARTS_ADMIN_TOKEN","HIGHCHARTS_CORE_SCRIPTS","HIGHCHARTS_MODULE_SCRIPTS","HIGHCHARTS_INDICATOR_SCRIPTS","HIGHCHARTS_CUSTOM_SCRIPTS","EXPORT_INFILE","EXPORT_INSTR","EXPORT_OPTIONS","EXPORT_SVG","EXPORT_BATCH","EXPORT_OUTFILE","EXPORT_TYPE","EXPORT_CONSTR","EXPORT_B64","EXPORT_NO_DOWNLOAD","EXPORT_HEIGHT","EXPORT_WIDTH","EXPORT_SCALE","EXPORT_DEFAULT_HEIGHT","EXPORT_DEFAULT_WIDTH","EXPORT_DEFAULT_SCALE","EXPORT_GLOBAL_OPTIONS","EXPORT_THEME_OPTIONS","EXPORT_RASTERIZATION_TIMEOUT","CUSTOM_LOGIC_ALLOW_CODE_EXECUTION","CUSTOM_LOGIC_ALLOW_FILE_RESOURCES","CUSTOM_LOGIC_CUSTOM_CODE","CUSTOM_LOGIC_CALLBACK","CUSTOM_LOGIC_RESOURCES","CUSTOM_LOGIC_LOAD_CONFIG","CUSTOM_LOGIC_CREATE_CONFIG","SERVER_ENABLE","SERVER_HOST","SERVER_PORT","SERVER_UPLOAD_LIMIT","SERVER_BENCHMARKING","SERVER_PROXY_HOST","SERVER_PROXY_PORT","SERVER_PROXY_TIMEOUT","SERVER_RATE_LIMITING_ENABLE","SERVER_RATE_LIMITING_MAX_REQUESTS","SERVER_RATE_LIMITING_WINDOW","SERVER_RATE_LIMITING_DELAY","SERVER_RATE_LIMITING_TRUST_PROXY","SERVER_RATE_LIMITING_SKIP_KEY","SERVER_RATE_LIMITING_SKIP_TOKEN","SERVER_SSL_ENABLE","SERVER_SSL_FORCE","SERVER_SSL_PORT","SERVER_SSL_CERT_PATH","POOL_MIN_WORKERS","POOL_MAX_WORKERS","POOL_WORK_LIMIT","POOL_ACQUIRE_TIMEOUT","POOL_CREATE_TIMEOUT","POOL_DESTROY_TIMEOUT","POOL_IDLE_TIMEOUT","POOL_CREATE_RETRY_INTERVAL","POOL_REAPER_INTERVAL","POOL_BENCHMARKING","LOGGING_LEVEL","LOGGING_FILE","LOGGING_DEST","LOGGING_TO_CONSOLE","LOGGING_TO_FILE","UI_ENABLE","UI_ROUTE","OTHER_NODE_ENV","OTHER_LISTEN_TO_PROCESS_EXITS","OTHER_NO_LOGO","OTHER_HARD_RESET_PAGE","OTHER_BROWSER_SHELL_MODE","OTHER_VALIDATION","DEBUG_ENABLE","DEBUG_HEADLESS","DEBUG_DEVTOOLS","DEBUG_LISTEN_TO_CONSOLE","DEBUG_DUMPIO","DEBUG_SLOW_MO","DEBUG_DEBUGGING_PORT","envs","parse","env","strictValidate","configOptions","looseValidate","context","propertyName","propertyInfo","code","ZodIssueCode","invalid_type","received","ZodParsedType","defaultError","custom","data","invalid_union","unionErrors","forEach","index","substring","ExportError","Error","constructor","statusCode","super","setError","name","_initOptions","nestedProps","_createNestedProps","absoluteProps","_createAbsoluteProps","getOptions","getCopy","updateOptions","newOptions","_mergeOptions","validateOptions","mapToNewOptions","oldOptions","entries","propertiesChain","reduce","obj","prop","validateOption","configOption","isAllowedConfig","allowFunctions","objectConfig","eval","JSON","stringifiedOptions","_optionsStringify","parsedOptions","_","originalOptions","stringifyFunctions","stringify","replaceAll","propChain","entry","async","get","requestOptions","Promise","reject","_getProtocolModule","response","responseData","on","chunk","text","https","http","cache","activeManifest","sources","hcVersion","checkCache","highchartsOptions","serverProxyOptions","fetchedModules","getCachePath","manifestPath","sourcePath","recursive","_updateCache","requestUpdate","manifest","readFileSync","modules","moduleMap","m","numberOfModules","moduleName","_extractHcVersion","_saveConfigToManifest","getHcVersion","updateHcVersion","newVersion","writeFileSync","_configureRequest","all","cs","_fetchScript","ms","is","script","shouldThrowError","_extractModuleName","agent","HttpsProxyAgent","cacheSources","replace","scriptPath","setupHighcharts","Highcharts","animObject","duration","createChart","exportOptions","customLogicOptions","setOptions","merge","wrap","setOptionsObj","isRenderComplete","Chart","proceed","userOptions","cb","exporting","enabled","plotOptions","series","label","tooltip","animation","onHighchartsRender","addEvent","Series","chart","Function","finalOptions","finalCallback","images","document","querySelectorAll","race","image","complete","naturalHeight","addEventListener","once","setTimeout","defaultOptions","pageTemplate","browser","createBrowser","puppeteerArgs","enabledDebug","debugOptions","launchOptions","userDataDir","handleSIGINT","handleSIGTERM","handleSIGHUP","waitForInitialPage","defaultViewport","tryCount","openBrowser","launch","closeBrowser","connected","close","newPage","poolResource","page","setCacheEnabled","_setPageContent","_setPageEvents","isClosed","clearPage","hardReset","goto","waitUntil","evaluate","body","innerHTML","id","workCount","addPageResources","injectedResources","injectedJs","content","isLocal","jsResource","addScriptTag","injectedCss","cssImports","match","cssImportPath","cssResource","addStyleTag","clearPageResources","resource","dispose","oldCharts","charts","oldChart","destroy","scriptsToRemove","getElementsByTagName","stylesToRemove","linksToRemove","element","remove","setContent","cssTemplate","svgTemplate","puppeteerExport","isSVG","size","_getChartSize","x","y","_getClipRegion","viewportHeight","abs","ceil","chartHeight","viewportWidth","chartWidth","result","setViewport","deviceScaleFactor","parseFloat","_createSVG","_createImage","_createPDF","$eval","getBoundingClientRect","trunc","svgElement","querySelector","baseVal","style","zoom","margin","outerHTML","clip","screenshot","encoding","fullPage","optimizeForSpeed","captureBeyondViewport","quality","omitBackground","_resolve","emulateMediaType","pdf","poolStats","exportsAttempted","exportsPerformed","exportsDropped","exportsFromSvg","exportsFromOptions","exportsFromSvgAttempts","exportsFromOptionsAttempts","timeSpent","timeSpentAverage","initPool","poolOptions","Pool","_factory","acquireTimeoutMillis","createTimeoutMillis","destroyTimeoutMillis","idleTimeoutMillis","createRetryIntervalMillis","reapIntervalMillis","propagateCreateError","clearStatus","_eventId","initialResources","i","acquire","promise","release","killPool","worker","used","destroyed","postWork","workerHandle","_getPoolInfo","acquireCounter","exportCounter","exportResult","getPoolStats","getPoolInfoJSON","numUsed","available","numFree","allCreated","pendingAcquires","numPendingAcquires","pendingCreates","numPendingCreates","pendingValidations","numPendingValidations","pendingDestroys","absoluteAll","create","random","startDate","validate","mainFrame","detached","removeAllListeners","sanitize","JSDOM","DOMPurify","ADD_TAGS","singleExport","startExport","batchExport","batchFunctions","pair","batchResults","allSettled","reason","imageOptions","endCallback","fileContent","_exportFromSvg","_exportFromOptions","getAllowCodeExecution","setAllowCodeExecution","inputToExport","_prepareExport","_fixConstr","_fixType","_fixOutfile","_handleCustomLogic","_handleGlobalAndTheme","_handleSize","_checkDataSize","fixedConstr","toLowerCase","mimeTypes","formats","outType","pop","find","t","optionsChart","optionsExporting","globalOptionsChart","globalOptionsExporting","themeOptionsChart","themeOptionsExporting","sourceHeight","sourceWidth","param","_handleResources","_handleCustomCode","handledResources","allowedProps","correctResources","propName","isCallback","optionsName","totalSize","byteLength","toFixed","timerIds","addTimer","clearAllTimers","clearInterval","clearTimeout","logErrorMiddleware","request","next","returnErrorMiddleware","status","json","errorMiddleware","app","use","rateLimitingMiddleware","rateLimitingOptions","rateOptions","limiter","rateLimit","windowMs","limit","delayMs","handler","format","send","default","skip","query","access_token","contentTypeMiddleware","contentType","headers","requestBodyMiddleware","connection","remoteAddress","validatedOptions","filename","validationMiddleware","post","reversedMime","png","jpeg","gif","requestExport","requestCounter","connectionAborted","socket","hadErrors","header","attachment","exportRoutes","serverStartTime","packageFile","successRates","recordInterval","windowSize","_calculateMovingAverage","a","b","_startSuccessRate","setInterval","stats","successRatio","healthRoutes","period","movingAverage","bootTime","uptime","floor","serverVersion","highchartsVersion","averageExportTime","attemptedExports","performedExports","failedExports","sucessRatio","svgExports","jsonExports","svgExportsAttempts","jsonExportsAttempts","uiRoutes","sendFile","acceptRanges","versionChangeRoutes","token","activeServers","Map","express","startServer","serverOptions","uploadLimitBytes","storage","multer","memoryStorage","upload","limits","fieldSize","disable","cors","methods","set","urlencoded","extended","none","static","httpServer","createServer","_attachServerErrorHandlers","listen","cert","httpsServer","closeServers","delete","getServers","getExpress","getApp","middlewares","shutdownCleanUp","exitCode","exit","initExport","initOptions","_attachProcessExitListeners"],"mappings":"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SAGVwF,WAAY,CACV9D,OAAO,EACPqD,MAAO,CAAC,WACRC,QAAS,yBACTE,YAAa,kDACbC,cAAe,CACbnF,KAAM,WAGVyF,UAAW,CACT/D,MAAO,SACPqD,MAAO,CAAC,UACRC,QAAS,wBACTE,YAAa,+CACbC,cAAe,CACbnF,KAAM,SAGV0F,YAAa,CACXhE,MAAO,CAAC,aAAc,kBAAmB,iBACzCqD,MAAO,CAAC,YACRC,QAAS,0BACTE,YAAa,mCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBC,cAAe,CACblE,MAAO,CACL,QACA,MACA,QACA,YACA,uBACA,gBAEA,eACA,QACA,OACA,aACA,mBACA,eACA,cACA,UACA,UACA,cACA,WACA,UACA,YACA,cACA,YACA,sBACA,SACA,SACA,WACA,aACA,YACA,eACA,yBACA,SACA,eACA,YACA,kBACA,SACA,cACA,mBACA,eACA,kBACA,cACA,eAEA,cACA,WACA,eACA,WACA,SACA,OACA,WACA,YACA,SACA,qBACA,aACA,WACA,WACA,WACA,WACA,eACA,UACA,kBACA,oBACA,aACA,UACA,cACA,YACA,YAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBE,iBAAkB,CAChBnE,MAAO,CAAC,kBACRqD,MAAO,CAAC,YACRC,QAAS,+BACTE,YAAa,wCACbC,cAAe,CACbnF,KAAM,cACN2F,aAAc,0DAGlBG,cAAe,CACbpE,MAAO,CACL,wEACA,kGAEFqD,MAAO,CAAC,YACRC,QAAS,4BACTE,YAAa,qDACbC,cAAe,CACbnF,KAAM,OACNoF,UAAW,OAIjBW,OAAQ,CACNC,OAAQ,CACNtE,MAAO,KACPqD,MAAO,CAAC,SAAU,QAClBC,QAAS,gBACTE,YACE,+DACFC,cAAe,CACbnF,KAAM,SAGViG,MAAO,CACLvE,MAAO,KACPqD,MAAO,CAAC,SAAU,SAAU,QAC5BC,QAAS,eACTE,YACE,mEACFC,cAAe,CACbnF,KAAM,SAGVkG,QAAS,CACPxE,MAAO,KACPqD,MAAO,CAAC,SAAU,S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"} \ No newline at end of file diff --git a/lib/chart.js b/lib/chart.js index 6843fb68..7c33c24f 100644 --- a/lib/chart.js +++ b/lib/chart.js @@ -716,6 +716,12 @@ function _handleCustomLogic(customLogicOptions) { customLogicOptions.allowFileResources, true ); + + // Validate option + customLogicOptions.resources = validateOption( + 'resources', + customLogicOptions.resources + ); } catch (error) { log(2, '[chart] The `resources` cannot be loaded.'); @@ -878,9 +884,6 @@ function _handleResources( } } - // Validate option - handledResources = validateOption('resources', handledResources); - // Return resources return handledResources; } diff --git a/lib/index.js b/lib/index.js index 2bad49b3..b011b6ae 100644 --- a/lib/index.js +++ b/lib/index.js @@ -62,11 +62,12 @@ import server from './server/server.js'; * @async * @function initExport * - * @param {Object} initOptions - The `initOptions` object, which may + * @param {Object} [initOptions={}] - The `initOptions` object, which may * be a partial or complete set of options. If the options are partial, missing - * values will default to the current global configuration. + * values will default to the current global configuration. The default value + * is an empty object. */ -export async function initExport(initOptions) { +export async function initExport(initOptions = {}) { // Init, validate and update the options object const options = updateOptions(initOptions); diff --git a/lib/server/server.js b/lib/server/server.js index d1120384..a68045ca 100644 --- a/lib/server/server.js +++ b/lib/server/server.js @@ -59,10 +59,11 @@ const app = express(); * @async * @function startServer * - * @param {Object} serverOptions - The configuration object containing `server` - * options. This object may include a partial or complete set of the `server` - * options. If the options are partial, missing values will default - * to the current global configuration. + * @param {Object} [serverOptions={}] - The configuration object containing + * `server` options. This object may include a partial or complete set + * of the `server` options. If the options are partial, missing values will + * default to the current global configuration. The default value is an empty + * object. * * @returns {Promise} A Promise that resolves when the server is either * not enabled or no valid Express app is found, signaling the end of the @@ -71,7 +72,7 @@ const app = express(); * @throws {ExportError} Throws an `ExportError` if the server cannot * be configured and started. */ -export async function startServer(serverOptions) { +export async function startServer(serverOptions = {}) { try { // Update the instance options object const options = updateOptions({ From d258e74d167bacee97dfb994205c6f6865fd33ee Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Fri, 14 Feb 2025 14:43:38 +0100 Subject: [PATCH 18/19] Small logs corrections. --- lib/config.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/config.js b/lib/config.js index 1c60453a..b48b0017 100644 --- a/lib/config.js +++ b/lib/config.js @@ -119,7 +119,7 @@ export function setCliOptions(cliArgs) { // Update global options with validated values from the `configOptions` updateOptions(configOptions); } catch (error) { - log(2, '[validation] No options added from the `--loadConfig` option.'); + log(2, '[config] No options added from the `--loadConfig` option.'); } try { @@ -129,7 +129,7 @@ export function setCliOptions(cliArgs) { // Update global options with validated values from the `cliOptions` updateOptions(cliOptions, false, false); } catch (error) { - log(2, '[validation] No options added from the CLI arguments.'); + log(2, '[config] No options added from the CLI arguments.'); } } From 5f348f350bbffc7333b8e79f9a5e2ba4b381f970 Mon Sep 17 00:00:00 2001 From: PaulDalek Date: Fri, 14 Feb 2025 14:46:27 +0100 Subject: [PATCH 19/19] Updated the CHANGELOG.md file. --- CHANGELOG.md | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ce1bf4b..5af519eb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,9 @@ _Breaking Changes:_ _New Features:_ +- Added a toggleable type validation for all options coming from various sources (environment variables, custom JSON, CLI arguments), providing a rich set of validators with both strict and loose validation. Replaced the `envs.js` module with an expanded validation logic module, `validation.js`. +- Added the `validateOption` function for validating a single option. It is used in the code to validate individual options (`svg`, `instr`, `resources`, `customCode`, `callback`, `globalOptions`, and `themeOptions`) loaded from a file. +- Added the `validateOptions` function for validating the full set of options. It is used in the code to validate options coming from functions that update global options, CLI arguments, configurations loaded via `--loadConfig`, and configurations created using the prompts functionality. - Introduced redefined `getOptions` and `updateOptions` functions to retrieve and update the original global options or a copy of global options, allowing flexibility in export scenarios. - Added a new option called `uploadLimit` to control the maximum size of a request's payload body. - Added the possibility to return a Base64 version of the chart using any export method (not only through requests). @@ -27,6 +30,7 @@ _Enhancements:_ - Adjusted the options loading sequence: `default config -> environment variables` at initialization, `custom JSON -> CLI arguments` when using `setCliOptions` (CLI exports only). - The `getOptions` function can now return either a direct reference to the `globalOptions` or a copy (by setting the `getCopy` flag). - The `updateOptions` function can now update and return either a direct reference to the `globalOptions` or a copy (by setting the `getCopy` flag). +- The `updateOptions` function now validates provided options (using `validateOptions` internally) before merging them into the global options. - The `_mergeOptions` (renamed from the `mergeConfigOptions`) modifies the first object directly now and is used internally. - Replaced the fixed `absoluteProps` array (previously in `./lib/schemas/config.js`) with dynamic generation via `_createAbsoluteProps` function. - Enhanced the `isAllowedConfig` (renamed from the `isCorrectJSON`) and `_optionsStringify` functions to better handle stringified options in JSON. @@ -49,16 +53,16 @@ _Enhancements:_ - Created `_handleSize` for handling the `height`, `width`, and `scale` options. - Created `_checkDataSize` for handling the data size validation. - Optimized `initExport`, utilizing `updateOptions` for global option updates. -- The `initExport` now have its options parameters set as optional, using global option values if not provided. +- The `initExport` now have its options parameters defaulted to an empty object, using global option values if none are provided. - Updated exported API functions for module usage. - Adjusted imports to get functions from corresponding modules rather than `index.js`. - Server functions are now directly exported (rather than within a `server` object) as API functions. - The `logger` API functions that modify options now update global options. -- Added following API functions: `getOptions`, `updateOptions`, `mapToNewOptions`, `enableConsoleLogging`. +- Exposed `getOptions`, `updateOptions`, `mapToNewOptions`, `enableConsoleLogging`, `validateOption`, `validateOptions`, and `logZodIssues` as API functions. - Small corrections of the `_attachProcessExitListeners` (renamed from the `attachProcessExitListeners`). - Refactored logic for initial configuration, startup, and HTTP/HTTPS server management. - Optimized `startServer`, utilizing `updateOptions` for global option updates. -- The `startServer` now have its options parameters set as optional, using global option values if not provided. +- The `startServer` now have its options parameters defaulted to an empty object, using global option values if none are provided. - Optimized logic and statistics display in `health.js` router. - Optimized logic and corrected the url (from `version/change` to `version_change`) in the `versionChange.js` router. - Refactored `exportHandler` (to `requestExport`) by moving some logic to the `validaion` middleware and refactoring the rest. @@ -89,6 +93,7 @@ _Enhancements:_ - Renamed the `get` function to `getBrowser`, the `create` function to `createBrowser`, and the `close` function to `closeBrowser`. - Renamed `triggerExport` to `createChart`, optimizing the options passed and processed in the `highcharts.js` module. - Improved the module's overall logic, optimizing logging functions and the initialization process. +- Added the `logZodIssues` function for displaying correctly formatted validation errors. - Added `pathToLog` to the module's logging options to remember the full path to the log file. - Added the `enableConsoleLogging` function. - Removed `listen` function and `listeners` array from the module's logging options. @@ -118,12 +123,14 @@ _Enhancements:_ - Enhanced all files with improved JSDoc tags, descriptions, and comments, adding extra tags such as `@overview`, `@async`, and `@function`. - Corrected function descriptions, parameter types, return values, and documented errors. - Fixed all tests, samples, and scenario runners. +- Added unit tests for validating each option from every source (CLI, config, environment variables). - Created, renamed, or removed various tests, samples, and scenario runners. - Removed separate test runner scripts. - Made a minor correction in the `build` script. - Updated package versions. - Corrected the description of options prioritization order in the `Configuration` section. - Added explanations of overall option handling, management, and processing, along with descriptions for each export method (`Options Handling` section and subsections). +- Added a description of options validation in the `Options Validation` section. - Added, updated, corrected, or redefined descriptions and values of options in the following sections: `Default JSON Config`, `Environment Variables`, `Custom JSON Config`, `Command Line Arguments`, `HTTP Server POST Arguments`. - Fixed an incorrect version change endpoint description in the `Switching Highcharts Version at Runtime` section. - Corrected example and added description of the `Node.js Module` section.