rezo 1.0.67 → 1.0.69

package/dist/wget/robots.js

@@ -0,0 +1,300 @@
+const DEFAULT_USER_AGENT = "Rezo-Wget";
+
+export class RobotsHandler {
+  options;
+  userAgent;
+  cache = new Map;
+  pending = new Map;
+  constructor(options) {
+    this.options = options;
+    this.userAgent = this.extractBotName(options.userAgent || DEFAULT_USER_AGENT);
+  }
+  extractBotName(userAgent) {
+    const match = userAgent.match(/^([^\s\/]+)/);
+    return match ? match[1].toLowerCase() : userAgent.toLowerCase();
+  }
+  async fetch(url, fetcher) {
+    if (this.options.noRobots || this.options.robots === false) {
+      return null;
+    }
+    const domain = this.getDomain(url);
+    if (!domain)
+      return null;
+    if (this.cache.has(domain)) {
+      return this.cache.get(domain) || null;
+    }
+    if (this.pending.has(domain)) {
+      await this.pending.get(domain);
+      return this.cache.get(domain) || null;
+    }
+    const robotsUrl = this.getRobotsUrl(url);
+    const fetchPromise = (async () => {
+      try {
+        const content = await fetcher(robotsUrl);
+        if (content) {
+          const parsed = this.parse(content);
+          this.cache.set(domain, parsed);
+        } else {
+          this.cache.set(domain, null);
+        }
+      } catch {
+        this.cache.set(domain, null);
+      } finally {
+        this.pending.delete(domain);
+      }
+    })();
+    this.pending.set(domain, fetchPromise);
+    await fetchPromise;
+    return this.cache.get(domain) || null;
+  }
+  isAllowed(url) {
+    if (this.options.noRobots || this.options.robots === false) {
+      return true;
+    }
+    const domain = this.getDomain(url);
+    if (!domain)
+      return true;
+    const parsed = this.cache.get(domain);
+    if (!parsed) {
+      return true;
+    }
+    try {
+      const parsedUrl = new URL(url);
+      const path = parsedUrl.pathname + parsedUrl.search;
+      return this.isPathAllowed(path, parsed.rules);
+    } catch {
+      return true;
+    }
+  }
+  isPathAllowed(path, rules) {
+    const matchingRules = this.findMatchingRules(rules);
+    if (matchingRules.length === 0) {
+      return true;
+    }
+    const allAllows = [];
+    const allDisallows = [];
+    for (const rule of matchingRules) {
+      allAllows.push(...rule.allow);
+      allDisallows.push(...rule.disallow);
+    }
+    let bestMatch = null;
+    let bestLength = -1;
+    for (const pattern of allAllows) {
+      if (this.pathMatches(path, pattern)) {
+        const specificity = this.getSpecificity(pattern);
+        if (specificity > bestLength) {
+          bestLength = specificity;
+          bestMatch = { pattern, allow: true };
+        }
+      }
+    }
+    for (const pattern of allDisallows) {
+      if (this.pathMatches(path, pattern)) {
+        const specificity = this.getSpecificity(pattern);
+        if (specificity > bestLength) {
+          bestLength = specificity;
+          bestMatch = { pattern, allow: false };
+        }
+      }
+    }
+    if (!bestMatch) {
+      return true;
+    }
+    return bestMatch.allow;
+  }
+  findMatchingRules(rules) {
+    const matching = [];
+    let hasSpecificMatch = false;
+    for (const rule of rules) {
+      const ruleAgent = rule.userAgent.toLowerCase();
+      if (ruleAgent === this.userAgent) {
+        matching.push(rule);
+        hasSpecificMatch = true;
+      }
+    }
+    if (hasSpecificMatch) {
+      return matching;
+    }
+    for (const rule of rules) {
+      const ruleAgent = rule.userAgent.toLowerCase();
+      if (this.userAgent.includes(ruleAgent) || ruleAgent.includes(this.userAgent)) {
+        matching.push(rule);
+      }
+    }
+    if (matching.length > 0) {
+      return matching;
+    }
+    for (const rule of rules) {
+      if (rule.userAgent === "*") {
+        matching.push(rule);
+      }
+    }
+    return matching;
+  }
+  pathMatches(path, pattern) {
+    if (!pattern)
+      return false;
+    if (pattern === "")
+      return false;
+    let regexStr = "";
+    let hasEndAnchor = false;
+    if (pattern.endsWith("$")) {
+      hasEndAnchor = true;
+      pattern = pattern.slice(0, -1);
+    }
+    for (const char of pattern) {
+      if (char === "*") {
+        regexStr += ".*";
+      } else if (".+?^${}()|[]\\".includes(char)) {
+        regexStr += "\\" + char;
+      } else {
+        regexStr += char;
+      }
+    }
+    regexStr = "^" + regexStr;
+    if (hasEndAnchor) {
+      regexStr += "$";
+    }
+    try {
+      const regex = new RegExp(regexStr);
+      return regex.test(path);
+    } catch {
+      return path.startsWith(pattern.replace(/\*/g, ""));
+    }
+  }
+  getSpecificity(pattern) {
+    return pattern.replace(/\*/g, "").length;
+  }
+  getCrawlDelay(urlOrDomain) {
+    const domain = urlOrDomain.includes("://") ? this.getDomain(urlOrDomain) : urlOrDomain;
+    if (!domain)
+      return null;
+    const parsed = this.cache.get(domain);
+    if (!parsed)
+      return null;
+    const matchingRules = this.findMatchingRules(parsed.rules);
+    for (const rule of matchingRules) {
+      if (rule.crawlDelay !== undefined) {
+        return rule.crawlDelay;
+      }
+    }
+    return null;
+  }
+  getSitemaps(urlOrDomain) {
+    const domain = urlOrDomain.includes("://") ? this.getDomain(urlOrDomain) : urlOrDomain;
+    if (!domain)
+      return [];
+    const parsed = this.cache.get(domain);
+    if (!parsed)
+      return [];
+    return parsed.sitemaps;
+  }
+  getParsed(urlOrDomain) {
+    const domain = urlOrDomain.includes("://") ? this.getDomain(urlOrDomain) : urlOrDomain;
+    if (!domain)
+      return null;
+    return this.cache.get(domain) || null;
+  }
+  parse(content) {
+    const rules = [];
+    const sitemaps = [];
+    let currentRule = null;
+    const lines = content.split(/\r?\n/);
+    for (let line of lines) {
+      const commentIndex = line.indexOf("#");
+      if (commentIndex !== -1) {
+        line = line.substring(0, commentIndex);
+      }
+      line = line.trim();
+      if (!line)
+        continue;
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1)
+        continue;
+      const directive = line.substring(0, colonIndex).trim().toLowerCase();
+      const value = line.substring(colonIndex + 1).trim();
+      switch (directive) {
+        case "user-agent":
+          if (currentRule && (currentRule.allow.length > 0 || currentRule.disallow.length > 0)) {
+            rules.push(currentRule);
+          }
+          currentRule = {
+            userAgent: value,
+            disallow: [],
+            allow: [],
+            sitemaps: []
+          };
+          break;
+        case "disallow":
+          if (currentRule) {
+            currentRule.disallow.push(value);
+          }
+          break;
+        case "allow":
+          if (currentRule) {
+            currentRule.allow.push(value);
+          }
+          break;
+        case "crawl-delay":
+          if (currentRule) {
+            const delay = parseFloat(value);
+            if (!isNaN(delay) && delay >= 0) {
+              currentRule.crawlDelay = delay;
+            }
+          }
+          break;
+        case "sitemap":
+          sitemaps.push(value);
+          break;
+      }
+    }
+    if (currentRule && (currentRule.allow.length > 0 || currentRule.disallow.length > 0)) {
+      rules.push(currentRule);
+    }
+    return {
+      rules,
+      sitemaps,
+      raw: content
+    };
+  }
+  getRobotsUrl(url) {
+    try {
+      const parsed = new URL(url);
+      return `${parsed.protocol}//${parsed.host}/robots.txt`;
+    } catch {
+      return "";
+    }
+  }
+  getDomain(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname.toLowerCase();
+    } catch {
+      return null;
+    }
+  }
+  hasFetched(urlOrDomain) {
+    const domain = urlOrDomain.includes("://") ? this.getDomain(urlOrDomain) : urlOrDomain;
+    if (!domain)
+      return false;
+    return this.cache.has(domain);
+  }
+  clearCache(urlOrDomain) {
+    if (urlOrDomain) {
+      const domain = urlOrDomain.includes("://") ? this.getDomain(urlOrDomain) : urlOrDomain;
+      if (domain) {
+        this.cache.delete(domain);
+      }
+    } else {
+      this.cache.clear();
+    }
+  }
+  getRulesCount(urlOrDomain) {
+    const domain = urlOrDomain.includes("://") ? this.getDomain(urlOrDomain) : urlOrDomain;
+    if (!domain)
+      return 0;
+    const parsed = this.cache.get(domain);
+    return parsed?.rules.length || 0;
+  }
+}
+export default RobotsHandler;

package/dist/wget/types.cjs

@@ -0,0 +1,200 @@
+class WgetError extends Error {
+  code;
+  url;
+  statusCode;
+  cause;
+  constructor(message, code, url, statusCode, cause) {
+    super(message);
+    this.name = "WgetError";
+    this.code = code;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, WgetError);
+    }
+  }
+  isNetworkError() {
+    const networkCodes = [
+      "ENOTFOUND",
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENETUNREACH",
+      "EHOSTUNREACH",
+      "ECONNABORTED",
+      "EPIPE",
+      "EAI_AGAIN"
+    ];
+    return networkCodes.includes(this.code);
+  }
+  isHttpError() {
+    return this.code.startsWith("HTTP_") || this.statusCode !== undefined && this.statusCode >= 400;
+  }
+  isRetryable() {
+    if (this.isNetworkError())
+      return true;
+    if (this.statusCode) {
+      return this.statusCode === 408 || this.statusCode === 429 || this.statusCode >= 500;
+    }
+    return false;
+  }
+  isProxyError() {
+    const proxyCodes = [
+      "REZ_PROXY_CONNECTION_FAILED",
+      "REZ_PROXY_AUTHENTICATION_FAILED",
+      "REZ_PROXY_PROTOCOL_ERROR",
+      "REZ_PROXY_TIMEOUT",
+      "REZ_SOCKS_CONNECTION_FAILED",
+      "REZ_SOCKS_AUTH_FAILED",
+      "REZ_SOCKS_HANDSHAKE_FAILED",
+      "REZ_SOCKS_PROTOCOL_ERROR",
+      "ECONNREFUSED",
+      "ECONNRESET"
+    ];
+    if (proxyCodes.includes(this.code))
+      return true;
+    const lowerMessage = this.message.toLowerCase();
+    return lowerMessage.includes("proxy") || lowerMessage.includes("socks");
+  }
+  static fromHttpStatus(url, statusCode, statusText) {
+    return new WgetError(`HTTP ${statusCode}: ${statusText}`, `HTTP_${statusCode}`, url, statusCode);
+  }
+  static fromNetworkError(url, error) {
+    const code = error.code || "NETWORK_ERROR";
+    return new WgetError(error.message, code, url, undefined, error);
+  }
+}
+function flattenWgetOptions(options) {
+  const flat = {};
+  if (options.logging) {
+    flat.quiet = options.logging.quiet;
+    flat.verbose = options.logging.verbose;
+    flat.debug = options.logging.debug;
+    flat.noVerbose = options.logging.noVerbose;
+    flat.reportSpeed = options.logging.reportSpeed;
+    flat.progress = options.logging.progress;
+    flat.showProgress = options.logging.showProgress;
+    flat.logFile = options.logging.logFile;
+    flat.appendOutput = options.logging.appendOutput;
+  }
+  if (options.download) {
+    flat.output = options.download.output;
+    flat.outputDir = options.download.outputDir;
+    flat.continueDownload = options.download.continue;
+    flat.timestamping = options.download.timestamping;
+    flat.noClobber = options.download.noClobber;
+    flat.backups = options.download.backups;
+    flat.adjustExtension = options.download.adjustExtension;
+    flat.contentDisposition = options.download.contentDisposition;
+    flat.contentOnError = options.download.contentOnError;
+    flat.tries = options.download.tries;
+    flat.retryConnrefused = options.download.retryConnrefused;
+    flat.waitRetry = options.download.waitRetry;
+    flat.maxProxyRetries = options.download.maxProxyRetries;
+    flat.retryProxyErrors = options.download.retryProxyErrors;
+    flat.timeout = options.download.timeout;
+    flat.connectTimeout = options.download.connectTimeout;
+    flat.readTimeout = options.download.readTimeout;
+    flat.dnsTimeout = options.download.dnsTimeout;
+    flat.wait = options.download.wait;
+    flat.randomWait = options.download.randomWait;
+    flat.limitRate = options.download.limitRate;
+    flat.quota = options.download.quota;
+    flat.concurrency = options.download.concurrency;
+  }
+  if (options.directories) {
+    flat.noDirectories = options.directories.noDirectories;
+    flat.forceDirectories = options.directories.forceDirectories;
+    flat.cutDirs = options.directories.cutDirs;
+    flat.protocolDirectories = options.directories.protocolDirectories;
+    flat.noHostDirectories = options.directories.noHostDirectories;
+    flat.organizeAssets = options.directories.organizeAssets;
+    flat.assetFolders = options.directories.assetFolders;
+  }
+  if (options.http) {
+    flat.userAgent = options.http.userAgent;
+    flat.referer = options.http.referer;
+    flat.headers = options.http.headers;
+    flat.method = options.http.method;
+    flat.maxRedirects = options.http.maxRedirects;
+    flat.noCheckCertificate = options.http.noCheckCertificate;
+    flat.postData = options.http.postData;
+    flat.postFile = options.http.postFile;
+    flat.httpUser = options.http.user;
+    flat.httpPassword = options.http.password;
+    if (options.http.cookies) {
+      flat.loadCookies = options.http.cookies.load;
+      flat.saveCookies = options.http.cookies.save;
+      flat.keepSessionCookies = options.http.cookies.keepSession;
+      flat.cookieJar = options.http.cookies.jar;
+    }
+  }
+  if (options.recursive) {
+    flat.recursive = options.recursive.enabled;
+    flat.depth = options.recursive.depth;
+    flat.deleteAfter = options.recursive.deleteAfter;
+    flat.convertLinks = options.recursive.convertLinks;
+    flat.backupConverted = options.recursive.backupConverted;
+    flat.mirror = options.recursive.mirror;
+    flat.pageRequisites = options.recursive.pageRequisites;
+    flat.strictComments = options.recursive.strictComments;
+  }
+  if (options.filter) {
+    flat.accept = options.filter.accept;
+    flat.reject = options.filter.reject;
+    flat.acceptRegex = options.filter.acceptRegex;
+    flat.rejectRegex = options.filter.rejectRegex;
+    flat.domains = options.filter.domains;
+    flat.excludeDomains = options.filter.excludeDomains;
+    flat.followTags = options.filter.followTags;
+    flat.ignoreTags = options.filter.ignoreTags;
+    flat.followFTP = options.filter.followFTP;
+    flat.spanHosts = options.filter.spanHosts;
+    flat.relativeOnly = options.filter.relativeOnly;
+    flat.noParent = options.filter.noParent;
+    flat.includeDirectories = options.filter.includeDirectories;
+    flat.excludeDirectories = options.filter.excludeDirectories;
+    flat.excludeExtensions = options.filter.excludeExtensions;
+    flat.excludeMimeTypes = options.filter.excludeMimeTypes;
+    flat.acceptAssetTypes = options.filter.acceptAssetTypes;
+    flat.rejectAssetTypes = options.filter.rejectAssetTypes;
+    flat.maxFileSize = options.filter.maxFileSize;
+    flat.minFileSize = options.filter.minFileSize;
+  }
+  if (options.robots) {
+    flat.robots = options.robots.enabled;
+    flat.noRobots = options.robots.enabled === false;
+  }
+  if (options.proxy) {
+    flat.proxy = options.proxy;
+  }
+  if (options.network) {
+    flat.inet4Only = options.network.inet4Only;
+    flat.inet6Only = options.network.inet6Only;
+    flat.preferFamily = options.network.preferFamily;
+  }
+  if (options.input) {
+    flat.inputFile = options.input.file;
+    flat.baseUrl = options.input.base;
+  }
+  if (options.misc) {
+    flat.background = options.misc.background;
+    flat.execute = options.misc.execute;
+    flat.restrictFileNames = options.misc.restrictFileNames;
+    flat.signal = options.misc.signal;
+  }
+  if (options.organizeAssets !== undefined) {
+    flat.organizeAssets = options.organizeAssets;
+  }
+  if (options.assetFolders !== undefined) {
+    flat.assetFolders = options.assetFolders;
+  }
+  if (options.cache !== undefined) {
+    flat.cache = options.cache;
+  }
+  return Object.fromEntries(Object.entries(flat).filter(([_, v]) => v !== undefined));
+}
+
+exports.WgetError = WgetError;
+exports.flattenWgetOptions = flattenWgetOptions;

package/dist/wget/types.js

@@ -0,0 +1,197 @@
+export class WgetError extends Error {
+  code;
+  url;
+  statusCode;
+  cause;
+  constructor(message, code, url, statusCode, cause) {
+    super(message);
+    this.name = "WgetError";
+    this.code = code;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, WgetError);
+    }
+  }
+  isNetworkError() {
+    const networkCodes = [
+      "ENOTFOUND",
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENETUNREACH",
+      "EHOSTUNREACH",
+      "ECONNABORTED",
+      "EPIPE",
+      "EAI_AGAIN"
+    ];
+    return networkCodes.includes(this.code);
+  }
+  isHttpError() {
+    return this.code.startsWith("HTTP_") || this.statusCode !== undefined && this.statusCode >= 400;
+  }
+  isRetryable() {
+    if (this.isNetworkError())
+      return true;
+    if (this.statusCode) {
+      return this.statusCode === 408 || this.statusCode === 429 || this.statusCode >= 500;
+    }
+    return false;
+  }
+  isProxyError() {
+    const proxyCodes = [
+      "REZ_PROXY_CONNECTION_FAILED",
+      "REZ_PROXY_AUTHENTICATION_FAILED",
+      "REZ_PROXY_PROTOCOL_ERROR",
+      "REZ_PROXY_TIMEOUT",
+      "REZ_SOCKS_CONNECTION_FAILED",
+      "REZ_SOCKS_AUTH_FAILED",
+      "REZ_SOCKS_HANDSHAKE_FAILED",
+      "REZ_SOCKS_PROTOCOL_ERROR",
+      "ECONNREFUSED",
+      "ECONNRESET"
+    ];
+    if (proxyCodes.includes(this.code))
+      return true;
+    const lowerMessage = this.message.toLowerCase();
+    return lowerMessage.includes("proxy") || lowerMessage.includes("socks");
+  }
+  static fromHttpStatus(url, statusCode, statusText) {
+    return new WgetError(`HTTP ${statusCode}: ${statusText}`, `HTTP_${statusCode}`, url, statusCode);
+  }
+  static fromNetworkError(url, error) {
+    const code = error.code || "NETWORK_ERROR";
+    return new WgetError(error.message, code, url, undefined, error);
+  }
+}
+export function flattenWgetOptions(options) {
+  const flat = {};
+  if (options.logging) {
+    flat.quiet = options.logging.quiet;
+    flat.verbose = options.logging.verbose;
+    flat.debug = options.logging.debug;
+    flat.noVerbose = options.logging.noVerbose;
+    flat.reportSpeed = options.logging.reportSpeed;
+    flat.progress = options.logging.progress;
+    flat.showProgress = options.logging.showProgress;
+    flat.logFile = options.logging.logFile;
+    flat.appendOutput = options.logging.appendOutput;
+  }
+  if (options.download) {
+    flat.output = options.download.output;
+    flat.outputDir = options.download.outputDir;
+    flat.continueDownload = options.download.continue;
+    flat.timestamping = options.download.timestamping;
+    flat.noClobber = options.download.noClobber;
+    flat.backups = options.download.backups;
+    flat.adjustExtension = options.download.adjustExtension;
+    flat.contentDisposition = options.download.contentDisposition;
+    flat.contentOnError = options.download.contentOnError;
+    flat.tries = options.download.tries;
+    flat.retryConnrefused = options.download.retryConnrefused;
+    flat.waitRetry = options.download.waitRetry;
+    flat.maxProxyRetries = options.download.maxProxyRetries;
+    flat.retryProxyErrors = options.download.retryProxyErrors;
+    flat.timeout = options.download.timeout;
+    flat.connectTimeout = options.download.connectTimeout;
+    flat.readTimeout = options.download.readTimeout;
+    flat.dnsTimeout = options.download.dnsTimeout;
+    flat.wait = options.download.wait;
+    flat.randomWait = options.download.randomWait;
+    flat.limitRate = options.download.limitRate;
+    flat.quota = options.download.quota;
+    flat.concurrency = options.download.concurrency;
+  }
+  if (options.directories) {
+    flat.noDirectories = options.directories.noDirectories;
+    flat.forceDirectories = options.directories.forceDirectories;
+    flat.cutDirs = options.directories.cutDirs;
+    flat.protocolDirectories = options.directories.protocolDirectories;
+    flat.noHostDirectories = options.directories.noHostDirectories;
+    flat.organizeAssets = options.directories.organizeAssets;
+    flat.assetFolders = options.directories.assetFolders;
+  }
+  if (options.http) {
+    flat.userAgent = options.http.userAgent;
+    flat.referer = options.http.referer;
+    flat.headers = options.http.headers;
+    flat.method = options.http.method;
+    flat.maxRedirects = options.http.maxRedirects;
+    flat.noCheckCertificate = options.http.noCheckCertificate;
+    flat.postData = options.http.postData;
+    flat.postFile = options.http.postFile;
+    flat.httpUser = options.http.user;
+    flat.httpPassword = options.http.password;
+    if (options.http.cookies) {
+      flat.loadCookies = options.http.cookies.load;
+      flat.saveCookies = options.http.cookies.save;
+      flat.keepSessionCookies = options.http.cookies.keepSession;
+      flat.cookieJar = options.http.cookies.jar;
+    }
+  }
+  if (options.recursive) {
+    flat.recursive = options.recursive.enabled;
+    flat.depth = options.recursive.depth;
+    flat.deleteAfter = options.recursive.deleteAfter;
+    flat.convertLinks = options.recursive.convertLinks;
+    flat.backupConverted = options.recursive.backupConverted;
+    flat.mirror = options.recursive.mirror;
+    flat.pageRequisites = options.recursive.pageRequisites;
+    flat.strictComments = options.recursive.strictComments;
+  }
+  if (options.filter) {
+    flat.accept = options.filter.accept;
+    flat.reject = options.filter.reject;
+    flat.acceptRegex = options.filter.acceptRegex;
+    flat.rejectRegex = options.filter.rejectRegex;
+    flat.domains = options.filter.domains;
+    flat.excludeDomains = options.filter.excludeDomains;
+    flat.followTags = options.filter.followTags;
+    flat.ignoreTags = options.filter.ignoreTags;
+    flat.followFTP = options.filter.followFTP;
+    flat.spanHosts = options.filter.spanHosts;
+    flat.relativeOnly = options.filter.relativeOnly;
+    flat.noParent = options.filter.noParent;
+    flat.includeDirectories = options.filter.includeDirectories;
+    flat.excludeDirectories = options.filter.excludeDirectories;
+    flat.excludeExtensions = options.filter.excludeExtensions;
+    flat.excludeMimeTypes = options.filter.excludeMimeTypes;
+    flat.acceptAssetTypes = options.filter.acceptAssetTypes;
+    flat.rejectAssetTypes = options.filter.rejectAssetTypes;
+    flat.maxFileSize = options.filter.maxFileSize;
+    flat.minFileSize = options.filter.minFileSize;
+  }
+  if (options.robots) {
+    flat.robots = options.robots.enabled;
+    flat.noRobots = options.robots.enabled === false;
+  }
+  if (options.proxy) {
+    flat.proxy = options.proxy;
+  }
+  if (options.network) {
+    flat.inet4Only = options.network.inet4Only;
+    flat.inet6Only = options.network.inet6Only;
+    flat.preferFamily = options.network.preferFamily;
+  }
+  if (options.input) {
+    flat.inputFile = options.input.file;
+    flat.baseUrl = options.input.base;
+  }
+  if (options.misc) {
+    flat.background = options.misc.background;
+    flat.execute = options.misc.execute;
+    flat.restrictFileNames = options.misc.restrictFileNames;
+    flat.signal = options.misc.signal;
+  }
+  if (options.organizeAssets !== undefined) {
+    flat.organizeAssets = options.organizeAssets;
+  }
+  if (options.assetFolders !== undefined) {
+    flat.assetFolders = options.assetFolders;
+  }
+  if (options.cache !== undefined) {
+    flat.cache = options.cache;
+  }
+  return Object.fromEntries(Object.entries(flat).filter(([_, v]) => v !== undefined));
+}