// vite.generated.ts import path from "path"; import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs"; import { createHash } from "crypto"; import * as net from "net"; // target/plugins/application-theme-plugin/theme-handle.js import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs"; import { resolve as resolve3 } from "path"; // target/plugins/application-theme-plugin/theme-generator.js import { globSync as globSync2 } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/glob/dist/mjs/index.js"; import { resolve as resolve2, basename as basename2 } from "path"; import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs"; // target/plugins/application-theme-plugin/theme-copy.js import { readdirSync, statSync, mkdirSync, existsSync, copyFileSync } from "fs"; import { resolve, basename, relative, extname } from "path"; import { globSync } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/glob/dist/mjs/index.js"; var ignoredFileExtensions = [".css", ".js", ".json"]; function copyThemeResources(themeFolder2, projectStaticAssetsOutputFolder, logger) { const staticAssetsThemeFolder = resolve(projectStaticAssetsOutputFolder, "themes", basename(themeFolder2)); const collection = collectFolders(themeFolder2, logger); if (collection.files.length > 0) { mkdirSync(staticAssetsThemeFolder, { recursive: true }); collection.directories.forEach((directory) => { const relativeDirectory = relative(themeFolder2, directory); const targetDirectory = resolve(staticAssetsThemeFolder, relativeDirectory); mkdirSync(targetDirectory, { recursive: true }); }); collection.files.forEach((file) => { const relativeFile = relative(themeFolder2, file); const targetFile = resolve(staticAssetsThemeFolder, relativeFile); copyFileIfAbsentOrNewer(file, targetFile, logger); }); } } function collectFolders(folderToCopy, logger) { const collection = { directories: [], files: [] }; logger.trace("files in directory", readdirSync(folderToCopy)); readdirSync(folderToCopy).forEach((file) => { const fileToCopy = resolve(folderToCopy, file); try { if (statSync(fileToCopy).isDirectory()) { logger.debug("Going through directory", fileToCopy); const result = collectFolders(fileToCopy, logger); if (result.files.length > 0) { collection.directories.push(fileToCopy); logger.debug("Adding directory", fileToCopy); collection.directories.push.apply(collection.directories, result.directories); collection.files.push.apply(collection.files, result.files); } } else if (!ignoredFileExtensions.includes(extname(fileToCopy))) { logger.debug("Adding file", fileToCopy); collection.files.push(fileToCopy); } } catch (error) { handleNoSuchFileError(fileToCopy, error, logger); } }); return collection; } function copyStaticAssets(themeName, themeProperties, projectStaticAssetsOutputFolder, logger) { const assets = themeProperties["assets"]; if (!assets) { logger.debug("no assets to handle no static assets were copied"); return; } mkdirSync(projectStaticAssetsOutputFolder, { recursive: true }); const missingModules = checkModules(Object.keys(assets)); if (missingModules.length > 0) { throw Error( "Missing npm modules '" + missingModules.join("', '") + "' for assets marked in 'theme.json'.\nInstall package(s) by adding a @NpmPackage annotation or install it using 'npm/pnpm/bun i'" ); } Object.keys(assets).forEach((module) => { const copyRules = assets[module]; Object.keys(copyRules).forEach((copyRule) => { const nodeSources = resolve("node_modules/", module, copyRule); const files = globSync(nodeSources, { nodir: true }); const targetFolder = resolve(projectStaticAssetsOutputFolder, "themes", themeName, copyRules[copyRule]); mkdirSync(targetFolder, { recursive: true }); files.forEach((file) => { const copyTarget = resolve(targetFolder, basename(file)); copyFileIfAbsentOrNewer(file, copyTarget, logger); }); }); }); } function checkModules(modules) { const missing = []; modules.forEach((module) => { if (!existsSync(resolve("node_modules/", module))) { missing.push(module); } }); return missing; } function copyFileIfAbsentOrNewer(fileToCopy, copyTarget, logger) { try { if (!existsSync(copyTarget) || statSync(copyTarget).mtime < statSync(fileToCopy).mtime) { logger.trace("Copying: ", fileToCopy, "=>", copyTarget); copyFileSync(fileToCopy, copyTarget); } } catch (error) { handleNoSuchFileError(fileToCopy, error, logger); } } function handleNoSuchFileError(file, error, logger) { if (error.code === "ENOENT") { logger.warn("Ignoring not existing file " + file + ". File may have been deleted during theme processing."); } else { throw error; } } // target/plugins/application-theme-plugin/theme-generator.js var themeComponentsFolder = "components"; var documentCssFilename = "document.css"; var stylesCssFilename = "styles.css"; var CSSIMPORT_COMMENT = "CSSImport end"; var headerImport = `import 'construct-style-sheets-polyfill'; `; function writeThemeFiles(themeFolder2, themeName, themeProperties, options) { const productionMode = !options.devMode; const useDevServerOrInProductionMode = !options.useDevBundle; const outputFolder = options.frontendGeneratedFolder; const styles = resolve2(themeFolder2, stylesCssFilename); const documentCssFile = resolve2(themeFolder2, documentCssFilename); const autoInjectComponents = themeProperties.autoInjectComponents ?? true; const globalFilename = "theme-" + themeName + ".global.generated.js"; const componentsFilename = "theme-" + themeName + ".components.generated.js"; const themeFilename = "theme-" + themeName + ".generated.js"; let themeFileContent = headerImport; let globalImportContent = "// When this file is imported, global styles are automatically applied\n"; let componentsFileContent = ""; var componentsFiles; if (autoInjectComponents) { componentsFiles = globSync2("*.css", { cwd: resolve2(themeFolder2, themeComponentsFolder), nodir: true }); if (componentsFiles.length > 0) { componentsFileContent += "import { unsafeCSS, registerStyles } from '@vaadin/vaadin-themable-mixin/register-styles';\n"; } } if (themeProperties.parent) { themeFileContent += `import { applyTheme as applyBaseTheme } from './theme-${themeProperties.parent}.generated.js'; `; } themeFileContent += `import { injectGlobalCss } from 'Frontend/generated/jar-resources/theme-util.js'; `; themeFileContent += `import './${componentsFilename}'; `; themeFileContent += `let needsReloadOnChanges = false; `; const imports = []; const componentCssImports = []; const globalFileContent = []; const globalCssCode = []; const shadowOnlyCss = []; const componentCssCode = []; const parentTheme = themeProperties.parent ? "applyBaseTheme(target);\n" : ""; const parentThemeGlobalImport = themeProperties.parent ? `import './theme-${themeProperties.parent}.global.generated.js'; ` : ""; const themeIdentifier = "_vaadintheme_" + themeName + "_"; const lumoCssFlag = "_vaadinthemelumoimports_"; const globalCssFlag = themeIdentifier + "globalCss"; const componentCssFlag = themeIdentifier + "componentCss"; if (!existsSync2(styles)) { if (productionMode) { throw new Error(`styles.css file is missing and is needed for '${themeName}' in folder '${themeFolder2}'`); } writeFileSync( styles, "/* Import your application global css files here or add the styles directly to this file */", "utf8" ); } let filename = basename2(styles); let variable = camelCase(filename); const lumoImports = themeProperties.lumoImports || ["color", "typography"]; if (lumoImports) { lumoImports.forEach((lumoImport) => { imports.push(`import { ${lumoImport} } from '@vaadin/vaadin-lumo-styles/${lumoImport}.js'; `); if (lumoImport === "utility" || lumoImport === "badge" || lumoImport === "typography" || lumoImport === "color") { imports.push(`import '@vaadin/vaadin-lumo-styles/${lumoImport}-global.js'; `); } }); lumoImports.forEach((lumoImport) => { shadowOnlyCss.push(`removers.push(injectGlobalCss(${lumoImport}.cssText, '', target, true)); `); }); } if (useDevServerOrInProductionMode) { globalFileContent.push(parentThemeGlobalImport); globalFileContent.push(`import 'themes/${themeName}/${filename}'; `); imports.push(`import ${variable} from 'themes/${themeName}/${filename}?inline'; `); shadowOnlyCss.push(`removers.push(injectGlobalCss(${variable}.toString(), '', target)); `); } if (existsSync2(documentCssFile)) { filename = basename2(documentCssFile); variable = camelCase(filename); if (useDevServerOrInProductionMode) { globalFileContent.push(`import 'themes/${themeName}/${filename}'; `); imports.push(`import ${variable} from 'themes/${themeName}/${filename}?inline'; `); shadowOnlyCss.push(`removers.push(injectGlobalCss(${variable}.toString(),'', document)); `); } } let i = 0; if (themeProperties.documentCss) { const missingModules = checkModules(themeProperties.documentCss); if (missingModules.length > 0) { throw Error( "Missing npm modules or files '" + missingModules.join("', '") + "' for documentCss marked in 'theme.json'.\nInstall or update package(s) by adding a @NpmPackage annotation or install it using 'npm/pnpm/bun i'" ); } themeProperties.documentCss.forEach((cssImport) => { const variable2 = "module" + i++; imports.push(`import ${variable2} from '${cssImport}?inline'; `); globalCssCode.push(`if(target !== document) { removers.push(injectGlobalCss(${variable2}.toString(), '', target)); } `); globalCssCode.push( `removers.push(injectGlobalCss(${variable2}.toString(), '${CSSIMPORT_COMMENT}', document)); ` ); }); } if (themeProperties.importCss) { const missingModules = checkModules(themeProperties.importCss); if (missingModules.length > 0) { throw Error( "Missing npm modules or files '" + missingModules.join("', '") + "' for importCss marked in 'theme.json'.\nInstall or update package(s) by adding a @NpmPackage annotation or install it using 'npm/pnpm/bun i'" ); } themeProperties.importCss.forEach((cssPath) => { const variable2 = "module" + i++; globalFileContent.push(`import '${cssPath}'; `); imports.push(`import ${variable2} from '${cssPath}?inline'; `); shadowOnlyCss.push(`removers.push(injectGlobalCss(${variable2}.toString(), '${CSSIMPORT_COMMENT}', target)); `); }); } if (autoInjectComponents) { componentsFiles.forEach((componentCss) => { const filename2 = basename2(componentCss); const tag = filename2.replace(".css", ""); const variable2 = camelCase(filename2); componentCssImports.push( `import ${variable2} from 'themes/${themeName}/${themeComponentsFolder}/${filename2}?inline'; ` ); const componentString = `registerStyles( '${tag}', unsafeCSS(${variable2}.toString()) ); `; componentCssCode.push(componentString); }); } themeFileContent += imports.join(""); const themeFileApply = ` let themeRemovers = new WeakMap(); let targets = []; export const applyTheme = (target) => { const removers = []; if (target !== document) { ${shadowOnlyCss.join("")} } ${parentTheme} ${globalCssCode.join("")} if (import.meta.hot) { targets.push(new WeakRef(target)); themeRemovers.set(target, removers); } } `; componentsFileContent += ` ${componentCssImports.join("")} if (!document['${componentCssFlag}']) { ${componentCssCode.join("")} document['${componentCssFlag}'] = true; } if (import.meta.hot) { import.meta.hot.accept((module) => { window.location.reload(); }); } `; themeFileContent += themeFileApply; themeFileContent += ` if (import.meta.hot) { import.meta.hot.accept((module) => { if (needsReloadOnChanges) { window.location.reload(); } else { targets.forEach(targetRef => { const target = targetRef.deref(); if (target) { themeRemovers.get(target).forEach(remover => remover()) module.applyTheme(target); } }) } }); import.meta.hot.on('vite:afterUpdate', (update) => { document.dispatchEvent(new CustomEvent('vaadin-theme-updated', { detail: update })); }); } `; globalImportContent += ` ${globalFileContent.join("")} `; writeIfChanged(resolve2(outputFolder, globalFilename), globalImportContent); writeIfChanged(resolve2(outputFolder, themeFilename), themeFileContent); writeIfChanged(resolve2(outputFolder, componentsFilename), componentsFileContent); } function writeIfChanged(file, data) { if (!existsSync2(file) || readFileSync(file, { encoding: "utf-8" }) !== data) { writeFileSync(file, data); } } function camelCase(str) { return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) { return index === 0 ? word.toLowerCase() : word.toUpperCase(); }).replace(/\s+/g, "").replace(/\.|\-/g, ""); } // target/plugins/application-theme-plugin/theme-handle.js var nameRegex = /theme-(.*)\.generated\.js/; var prevThemeName = void 0; var firstThemeName = void 0; function processThemeResources(options, logger) { const themeName = extractThemeName(options.frontendGeneratedFolder); if (themeName) { if (!prevThemeName && !firstThemeName) { firstThemeName = themeName; } else if (prevThemeName && prevThemeName !== themeName && firstThemeName !== themeName || !prevThemeName && firstThemeName !== themeName) { const warning = `Attention: Active theme is switched to '${themeName}'.`; const description = ` Note that adding new style sheet files to '/themes/${themeName}/components', may not be taken into effect until the next application restart. Changes to already existing style sheet files are being reloaded as before.`; logger.warn("*******************************************************************"); logger.warn(warning); logger.warn(description); logger.warn("*******************************************************************"); } prevThemeName = themeName; findThemeFolderAndHandleTheme(themeName, options, logger); } else { prevThemeName = void 0; logger.debug("Skipping Vaadin application theme handling."); logger.trace("Most likely no @Theme annotation for application or only themeClass used."); } } function findThemeFolderAndHandleTheme(themeName, options, logger) { let themeFound = false; for (let i = 0; i < options.themeProjectFolders.length; i++) { const themeProjectFolder = options.themeProjectFolders[i]; if (existsSync3(themeProjectFolder)) { logger.debug("Searching themes folder '" + themeProjectFolder + "' for theme '" + themeName + "'"); const handled = handleThemes(themeName, themeProjectFolder, options, logger); if (handled) { if (themeFound) { throw new Error( "Found theme files in '" + themeProjectFolder + "' and '" + themeFound + "'. Theme should only be available in one folder" ); } logger.debug("Found theme files from '" + themeProjectFolder + "'"); themeFound = themeProjectFolder; } } } if (existsSync3(options.themeResourceFolder)) { if (themeFound && existsSync3(resolve3(options.themeResourceFolder, themeName))) { throw new Error( "Theme '" + themeName + `'should not exist inside a jar and in the project at the same time Extending another theme is possible by adding { "parent": "my-parent-theme" } entry to the theme.json file inside your theme folder.` ); } logger.debug( "Searching theme jar resource folder '" + options.themeResourceFolder + "' for theme '" + themeName + "'" ); handleThemes(themeName, options.themeResourceFolder, options, logger); themeFound = true; } return themeFound; } function handleThemes(themeName, themesFolder, options, logger) { const themeFolder2 = resolve3(themesFolder, themeName); if (existsSync3(themeFolder2)) { logger.debug("Found theme ", themeName, " in folder ", themeFolder2); const themeProperties = getThemeProperties(themeFolder2); if (themeProperties.parent) { const found = findThemeFolderAndHandleTheme(themeProperties.parent, options, logger); if (!found) { throw new Error( "Could not locate files for defined parent theme '" + themeProperties.parent + "'.\nPlease verify that dependency is added or theme folder exists." ); } } copyStaticAssets(themeName, themeProperties, options.projectStaticAssetsOutputFolder, logger); copyThemeResources(themeFolder2, options.projectStaticAssetsOutputFolder, logger); writeThemeFiles(themeFolder2, themeName, themeProperties, options); return true; } return false; } function getThemeProperties(themeFolder2) { const themePropertyFile = resolve3(themeFolder2, "theme.json"); if (!existsSync3(themePropertyFile)) { return {}; } const themePropertyFileAsString = readFileSync2(themePropertyFile); if (themePropertyFileAsString.length === 0) { return {}; } return JSON.parse(themePropertyFileAsString); } function extractThemeName(frontendGeneratedFolder) { if (!frontendGeneratedFolder) { throw new Error( "Couldn't extract theme name from 'theme.js', because the path to folder containing this file is empty. Please set the a correct folder path in ApplicationThemePlugin constructor parameters." ); } const generatedThemeFile = resolve3(frontendGeneratedFolder, "theme.js"); if (existsSync3(generatedThemeFile)) { const themeName = nameRegex.exec(readFileSync2(generatedThemeFile, { encoding: "utf8" }))[1]; if (!themeName) { throw new Error("Couldn't parse theme name from '" + generatedThemeFile + "'."); } return themeName; } else { return ""; } } // target/plugins/theme-loader/theme-loader-utils.js import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs"; import { resolve as resolve4, basename as basename3 } from "path"; import { globSync as globSync3 } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/glob/dist/mjs/index.js"; var urlMatcher = /(url\(\s*)(\'|\")?(\.\/|\.\.\/)(\S*)(\2\s*\))/g; function assetsContains(fileUrl, themeFolder2, logger) { const themeProperties = getThemeProperties2(themeFolder2); if (!themeProperties) { logger.debug("No theme properties found."); return false; } const assets = themeProperties["assets"]; if (!assets) { logger.debug("No defined assets in theme properties"); return false; } for (let module of Object.keys(assets)) { const copyRules = assets[module]; for (let copyRule of Object.keys(copyRules)) { if (fileUrl.startsWith(copyRules[copyRule])) { const targetFile = fileUrl.replace(copyRules[copyRule], ""); const files = globSync3(resolve4("node_modules/", module, copyRule), { nodir: true }); for (let file of files) { if (file.endsWith(targetFile)) return true; } } } } return false; } function getThemeProperties2(themeFolder2) { const themePropertyFile = resolve4(themeFolder2, "theme.json"); if (!existsSync4(themePropertyFile)) { return {}; } const themePropertyFileAsString = readFileSync3(themePropertyFile); if (themePropertyFileAsString.length === 0) { return {}; } return JSON.parse(themePropertyFileAsString); } function rewriteCssUrls(source, handledResourceFolder, themeFolder2, logger, options) { source = source.replace(urlMatcher, function(match, url, quoteMark, replace2, fileUrl, endString) { let absolutePath = resolve4(handledResourceFolder, replace2, fileUrl); const existingThemeResource = absolutePath.startsWith(themeFolder2) && existsSync4(absolutePath); if (existingThemeResource || assetsContains(fileUrl, themeFolder2, logger)) { const replacement = options.devMode ? "./" : "../static/"; const skipLoader = existingThemeResource ? "" : replacement; const frontendThemeFolder = skipLoader + "themes/" + basename3(themeFolder2); logger.debug( "Updating url for file", "'" + replace2 + fileUrl + "'", "to use", "'" + frontendThemeFolder + "/" + fileUrl + "'" ); const pathResolved = absolutePath.substring(themeFolder2.length).replace(/\\/g, "/"); return url + (quoteMark ?? "") + frontendThemeFolder + pathResolved + endString; } else if (options.devMode) { logger.log("No rewrite for '", match, "' as the file was not found."); } else { return url + (quoteMark ?? "") + "../../" + fileUrl + endString; } return match; }); return source; } // target/vaadin-dev-server-settings.json var vaadin_dev_server_settings_default = { frontendFolder: "C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/frontend", themeFolder: "themes", themeResourceFolder: "C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/frontend/generated/jar-resources", staticOutput: "C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/classes/META-INF/VAADIN/webapp/VAADIN/static", generatedFolder: "generated", statsOutput: "C:\\Users\\mramirezg\\Documents\\ideaProjects\\soporte-t-cnico-t-i-v1-22\\soporte-t-cnico-t-i-v1-2\\target\\classes\\META-INF\\VAADIN\\config", frontendBundleOutput: "C:\\Users\\mramirezg\\Documents\\ideaProjects\\soporte-t-cnico-t-i-v1-22\\soporte-t-cnico-t-i-v1-2\\target\\classes\\META-INF\\VAADIN\\webapp", devBundleOutput: "C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/dev-bundle/webapp", devBundleStatsOutput: "C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/dev-bundle/config", jarResourcesFolder: "C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/frontend/generated/jar-resources", themeName: "soportet.iv1.2", clientServiceWorkerSource: "C:\\Users\\mramirezg\\Documents\\ideaProjects\\soporte-t-cnico-t-i-v1-22\\soporte-t-cnico-t-i-v1-2\\target\\sw.ts", pwaEnabled: true, offlineEnabled: true, offlinePath: "'.'" }; // vite.generated.ts import { defineConfig, mergeConfig } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/vite/dist/node/index.js"; import { getManifest } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/workbox-build/build/index.js"; import * as rollup from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/rollup/dist/es/rollup.js"; import brotli from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/rollup-plugin-brotli/lib/index.cjs.js"; import replace from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/@rollup/plugin-replace/dist/es/index.js"; import checker from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/vite-plugin-checker/dist/esm/main.js"; // target/plugins/rollup-plugin-postcss-lit-custom/rollup-plugin-postcss-lit.js import { createFilter } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/@rollup/pluginutils/dist/es/index.js"; import transformAst from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/transform-ast/index.js"; var assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g; var escape = (str) => str.replace(assetUrlRE, '${unsafeCSSTag("__VITE_ASSET__$1__$2")}').replace(/`/g, "\\`").replace(/\\(?!`)/g, "\\\\"); function postcssLit(options = {}) { const defaultOptions = { include: "**/*.{css,sss,pcss,styl,stylus,sass,scss,less}", exclude: null, importPackage: "lit" }; const opts = { ...defaultOptions, ...options }; const filter = createFilter(opts.include, opts.exclude); return { name: "postcss-lit", enforce: "post", transform(code, id) { if (!filter(id)) return; const ast = this.parse(code, {}); let defaultExportName; let isDeclarationLiteral = false; const magicString = transformAst(code, { ast }, (node) => { if (node.type === "ExportDefaultDeclaration") { defaultExportName = node.declaration.name; isDeclarationLiteral = node.declaration.type === "Literal"; } }); if (!defaultExportName && !isDeclarationLiteral) { return; } magicString.walk((node) => { if (defaultExportName && node.type === "VariableDeclaration") { const exportedVar = node.declarations.find((d) => d.id.name === defaultExportName); if (exportedVar) { exportedVar.init.edit.update(`cssTag\`${escape(exportedVar.init.value)}\``); } } if (isDeclarationLiteral && node.type === "ExportDefaultDeclaration") { node.declaration.edit.update(`cssTag\`${escape(node.declaration.value)}\``); } }); magicString.prepend(`import {css as cssTag, unsafeCSS as unsafeCSSTag} from '${opts.importPackage}'; `); return { code: magicString.toString(), map: magicString.generateMap({ hires: true }) }; } }; } // vite.generated.ts import { createRequire } from "module"; import { visualizer } from "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/node_modules/rollup-plugin-visualizer/dist/plugin/index.js"; var __vite_injected_original_dirname = "C:\\Users\\mramirezg\\Documents\\ideaProjects\\soporte-t-cnico-t-i-v1-22\\soporte-t-cnico-t-i-v1-2"; var __vite_injected_original_import_meta_url = "file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/vite.generated.ts"; var require2 = createRequire(__vite_injected_original_import_meta_url); var appShellUrl = "."; var frontendFolder = path.resolve(__vite_injected_original_dirname, vaadin_dev_server_settings_default.frontendFolder); var themeFolder = path.resolve(frontendFolder, vaadin_dev_server_settings_default.themeFolder); var frontendBundleFolder = path.resolve(__vite_injected_original_dirname, vaadin_dev_server_settings_default.frontendBundleOutput); var devBundleFolder = path.resolve(__vite_injected_original_dirname, vaadin_dev_server_settings_default.devBundleOutput); var devBundle = !!process.env.devBundle; var jarResourcesFolder = path.resolve(__vite_injected_original_dirname, vaadin_dev_server_settings_default.jarResourcesFolder); var themeResourceFolder = path.resolve(__vite_injected_original_dirname, vaadin_dev_server_settings_default.themeResourceFolder); var projectPackageJsonFile = path.resolve(__vite_injected_original_dirname, "package.json"); var buildOutputFolder = devBundle ? devBundleFolder : frontendBundleFolder; var statsFolder = path.resolve(__vite_injected_original_dirname, devBundle ? vaadin_dev_server_settings_default.devBundleStatsOutput : vaadin_dev_server_settings_default.statsOutput); var statsFile = path.resolve(statsFolder, "stats.json"); var bundleSizeFile = path.resolve(statsFolder, "bundle-size.html"); var nodeModulesFolder = path.resolve(__vite_injected_original_dirname, "node_modules"); var webComponentTags = ""; var projectIndexHtml = path.resolve(frontendFolder, "index.html"); var projectStaticAssetsFolders = [ path.resolve(__vite_injected_original_dirname, "src", "main", "resources", "META-INF", "resources"), path.resolve(__vite_injected_original_dirname, "src", "main", "resources", "static"), frontendFolder ]; var themeProjectFolders = projectStaticAssetsFolders.map((folder) => path.resolve(folder, vaadin_dev_server_settings_default.themeFolder)); var themeOptions = { devMode: false, useDevBundle: devBundle, // The following matches folder 'frontend/generated/themes/' // (not 'frontend/themes') for theme in JAR that is copied there themeResourceFolder: path.resolve(themeResourceFolder, vaadin_dev_server_settings_default.themeFolder), themeProjectFolders, projectStaticAssetsOutputFolder: devBundle ? path.resolve(devBundleFolder, "../assets") : path.resolve(__vite_injected_original_dirname, vaadin_dev_server_settings_default.staticOutput), frontendGeneratedFolder: path.resolve(frontendFolder, vaadin_dev_server_settings_default.generatedFolder) }; var hasExportedWebComponents = existsSync5(path.resolve(frontendFolder, "web-component.html")); console.trace = () => { }; console.debug = () => { }; function injectManifestToSWPlugin() { const rewriteManifestIndexHtmlUrl = (manifest) => { const indexEntry = manifest.find((entry) => entry.url === "index.html"); if (indexEntry) { indexEntry.url = appShellUrl; } return { manifest, warnings: [] }; }; return { name: "vaadin:inject-manifest-to-sw", async transform(code, id) { if (/sw\.(ts|js)$/.test(id)) { const { manifestEntries } = await getManifest({ globDirectory: buildOutputFolder, globPatterns: ["**/*"], globIgnores: ["**/*.br"], manifestTransforms: [rewriteManifestIndexHtmlUrl], maximumFileSizeToCacheInBytes: 100 * 1024 * 1024 // 100mb, }); return code.replace("self.__WB_MANIFEST", JSON.stringify(manifestEntries)); } } }; } function buildSWPlugin(opts) { let config; const devMode = opts.devMode; const swObj = {}; async function build(action, additionalPlugins = []) { const includedPluginNames = [ "vite:esbuild", "rollup-plugin-dynamic-import-variables", "vite:esbuild-transpile", "vite:terser" ]; const plugins = config.plugins.filter((p) => { return includedPluginNames.includes(p.name); }); const resolver = config.createResolver(); const resolvePlugin = { name: "resolver", resolveId(source, importer, _options) { return resolver(source, importer); } }; plugins.unshift(resolvePlugin); plugins.push( replace({ values: { "process.env.NODE_ENV": JSON.stringify(config.mode), ...config.define }, preventAssignment: true }) ); if (additionalPlugins) { plugins.push(...additionalPlugins); } const bundle = await rollup.rollup({ input: path.resolve(vaadin_dev_server_settings_default.clientServiceWorkerSource), plugins }); try { return await bundle[action]({ file: path.resolve(buildOutputFolder, "sw.js"), format: "es", exports: "none", sourcemap: config.command === "serve" || config.build.sourcemap, inlineDynamicImports: true }); } finally { await bundle.close(); } } return { name: "vaadin:build-sw", enforce: "post", async configResolved(resolvedConfig) { config = resolvedConfig; }, async buildStart() { if (devMode) { const { output } = await build("generate"); swObj.code = output[0].code; swObj.map = output[0].map; } }, async load(id) { if (id.endsWith("sw.js")) { return ""; } }, async transform(_code, id) { if (id.endsWith("sw.js")) { return swObj; } }, async closeBundle() { if (!devMode) { await build("write", [injectManifestToSWPlugin(), brotli()]); } } }; } function statsExtracterPlugin() { function collectThemeJsonsInFrontend(themeJsonContents, themeName) { const themeJson = path.resolve(frontendFolder, vaadin_dev_server_settings_default.themeFolder, themeName, "theme.json"); if (existsSync5(themeJson)) { const themeJsonContent = readFileSync4(themeJson, { encoding: "utf-8" }).replace(/\r\n/g, "\n"); themeJsonContents[themeName] = themeJsonContent; const themeJsonObject = JSON.parse(themeJsonContent); if (themeJsonObject.parent) { collectThemeJsonsInFrontend(themeJsonContents, themeJsonObject.parent); } } } return { name: "vaadin:stats", enforce: "post", async writeBundle(options, bundle) { const modules = Object.values(bundle).flatMap((b) => b.modules ? Object.keys(b.modules) : []); const nodeModulesFolders = modules.map((id) => id.replace(/\\/g, "/")).filter((id) => id.startsWith(nodeModulesFolder.replace(/\\/g, "/"))).map((id) => id.substring(nodeModulesFolder.length + 1)); const npmModules = nodeModulesFolders.map((id) => id.replace(/\\/g, "/")).map((id) => { const parts = id.split("/"); if (id.startsWith("@")) { return parts[0] + "/" + parts[1]; } else { return parts[0]; } }).sort().filter((value, index, self) => self.indexOf(value) === index); const npmModuleAndVersion = Object.fromEntries(npmModules.map((module) => [module, getVersion(module)])); const cvdls = Object.fromEntries( npmModules.filter((module) => getCvdlName(module) != null).map((module) => [module, { name: getCvdlName(module), version: getVersion(module) }]) ); mkdirSync2(path.dirname(statsFile), { recursive: true }); const projectPackageJson = JSON.parse(readFileSync4(projectPackageJsonFile, { encoding: "utf-8" })); const entryScripts = Object.values(bundle).filter((bundle2) => bundle2.isEntry).map((bundle2) => bundle2.fileName); const generatedIndexHtml = path.resolve(buildOutputFolder, "index.html"); const customIndexData = readFileSync4(projectIndexHtml, { encoding: "utf-8" }); const generatedIndexData = readFileSync4(generatedIndexHtml, { encoding: "utf-8" }); const customIndexRows = new Set(customIndexData.split(/[\r\n]/).filter((row) => row.trim() !== "")); const generatedIndexRows = generatedIndexData.split(/[\r\n]/).filter((row) => row.trim() !== ""); const rowsGenerated = []; generatedIndexRows.forEach((row) => { if (!customIndexRows.has(row)) { rowsGenerated.push(row); } }); const parseImports = (filename, result) => { const content = readFileSync4(filename, { encoding: "utf-8" }); const lines = content.split("\n"); const staticImports = lines.filter((line) => line.startsWith("import ")).map((line) => line.substring(line.indexOf("'") + 1, line.lastIndexOf("'"))).map((line) => line.includes("?") ? line.substring(0, line.lastIndexOf("?")) : line); const dynamicImports = lines.filter((line) => line.includes("import(")).map((line) => line.replace(/.*import\(/, "")).map((line) => line.split(/'/)[1]).map((line) => line.includes("?") ? line.substring(0, line.lastIndexOf("?")) : line); staticImports.forEach((staticImport) => result.add(staticImport)); dynamicImports.map((dynamicImport) => { const importedFile = path.resolve(path.dirname(filename), dynamicImport); parseImports(importedFile, result); }); }; const generatedImportsSet = /* @__PURE__ */ new Set(); parseImports( path.resolve(themeOptions.frontendGeneratedFolder, "flow", "generated-flow-imports.js"), generatedImportsSet ); const generatedImports = Array.from(generatedImportsSet).sort(); const frontendFiles = {}; const projectFileExtensions = [".js", ".js.map", ".ts", ".ts.map", ".tsx", ".tsx.map", ".css", ".css.map"]; const isThemeComponentsResource = (id) => id.startsWith(themeOptions.frontendGeneratedFolder.replace(/\\/g, "/")) && id.match(/.*\/jar-resources\/themes\/[^\/]+\/components\//); const isGeneratedWebComponentResource = (id) => id.startsWith(themeOptions.frontendGeneratedFolder.replace(/\\/g, "/")) && id.match(/.*\/flow\/web-components\//); const isFrontendResourceCollected = (id) => !id.startsWith(themeOptions.frontendGeneratedFolder.replace(/\\/g, "/")) || isThemeComponentsResource(id) || isGeneratedWebComponentResource(id); modules.map((id) => id.replace(/\\/g, "/")).filter((id) => id.startsWith(frontendFolder.replace(/\\/g, "/"))).filter(isFrontendResourceCollected).map((id) => id.substring(frontendFolder.length + 1)).map((line) => line.includes("?") ? line.substring(0, line.lastIndexOf("?")) : line).forEach((line) => { const filePath = path.resolve(frontendFolder, line); if (projectFileExtensions.includes(path.extname(filePath))) { const fileBuffer = readFileSync4(filePath, { encoding: "utf-8" }).replace(/\r\n/g, "\n"); frontendFiles[line] = createHash("sha256").update(fileBuffer, "utf8").digest("hex"); } }); generatedImports.filter((line) => line.includes("generated/jar-resources")).forEach((line) => { let filename = line.substring(line.indexOf("generated")); const fileBuffer = readFileSync4(path.resolve(frontendFolder, filename), { encoding: "utf-8" }).replace( /\r\n/g, "\n" ); const hash = createHash("sha256").update(fileBuffer, "utf8").digest("hex"); const fileKey = line.substring(line.indexOf("jar-resources/") + 14); frontendFiles[fileKey] = hash; }); let frontendFolderAlias = "Frontend"; generatedImports.filter((line) => line.startsWith(frontendFolderAlias + "/")).filter((line) => !line.startsWith(frontendFolderAlias + "/generated/")).filter((line) => !line.startsWith(frontendFolderAlias + "/themes/")).map((line) => line.substring(frontendFolderAlias.length + 1)).filter((line) => !frontendFiles[line]).forEach((line) => { const filePath = path.resolve(frontendFolder, line); if (projectFileExtensions.includes(path.extname(filePath)) && existsSync5(filePath)) { const fileBuffer = readFileSync4(filePath, { encoding: "utf-8" }).replace(/\r\n/g, "\n"); frontendFiles[line] = createHash("sha256").update(fileBuffer, "utf8").digest("hex"); } }); if (existsSync5(path.resolve(frontendFolder, "index.ts"))) { const fileBuffer = readFileSync4(path.resolve(frontendFolder, "index.ts"), { encoding: "utf-8" }).replace( /\r\n/g, "\n" ); frontendFiles[`index.ts`] = createHash("sha256").update(fileBuffer, "utf8").digest("hex"); } const themeJsonContents = {}; const themesFolder = path.resolve(jarResourcesFolder, "themes"); if (existsSync5(themesFolder)) { readdirSync2(themesFolder).forEach((themeFolder2) => { const themeJson = path.resolve(themesFolder, themeFolder2, "theme.json"); if (existsSync5(themeJson)) { themeJsonContents[path.basename(themeFolder2)] = readFileSync4(themeJson, { encoding: "utf-8" }).replace( /\r\n/g, "\n" ); } }); } collectThemeJsonsInFrontend(themeJsonContents, vaadin_dev_server_settings_default.themeName); let webComponents = []; if (webComponentTags) { webComponents = webComponentTags.split(";"); } const stats = { packageJsonDependencies: projectPackageJson.dependencies, npmModules: npmModuleAndVersion, bundleImports: generatedImports, frontendHashes: frontendFiles, themeJsonContents, entryScripts, webComponents, cvdlModules: cvdls, packageJsonHash: projectPackageJson?.vaadin?.hash, indexHtmlGenerated: rowsGenerated }; writeFileSync2(statsFile, JSON.stringify(stats, null, 1)); } }; } function vaadinBundlesPlugin() { const disabledMessage = "Vaadin component dependency bundles are disabled."; const modulesDirectory = nodeModulesFolder.replace(/\\/g, "/"); let vaadinBundleJson; function parseModuleId(id) { const [scope, scopedPackageName] = id.split("/", 3); const packageName = scope.startsWith("@") ? `${scope}/${scopedPackageName}` : scope; const modulePath = `.${id.substring(packageName.length)}`; return { packageName, modulePath }; } function getExports(id) { const { packageName, modulePath } = parseModuleId(id); const packageInfo = vaadinBundleJson.packages[packageName]; if (!packageInfo) return; const exposeInfo = packageInfo.exposes[modulePath]; if (!exposeInfo) return; const exportsSet = /* @__PURE__ */ new Set(); for (const e of exposeInfo.exports) { if (typeof e === "string") { exportsSet.add(e); } else { const { namespace, source } = e; if (namespace) { exportsSet.add(namespace); } else { const sourceExports = getExports(source); if (sourceExports) { sourceExports.forEach((e2) => exportsSet.add(e2)); } } } } return Array.from(exportsSet); } function getExportBinding(binding) { return binding === "default" ? "_default as default" : binding; } function getImportAssigment(binding) { return binding === "default" ? "default: _default" : binding; } return { name: "vaadin:bundles", enforce: "pre", apply(config, { command }) { if (command !== "serve") return false; try { const vaadinBundleJsonPath = require2.resolve("@vaadin/bundles/vaadin-bundle.json"); vaadinBundleJson = JSON.parse(readFileSync4(vaadinBundleJsonPath, { encoding: "utf8" })); } catch (e) { if (typeof e === "object" && e.code === "MODULE_NOT_FOUND") { vaadinBundleJson = { packages: {} }; console.info(`@vaadin/bundles npm package is not found, ${disabledMessage}`); return false; } else { throw e; } } const versionMismatches = []; for (const [name, packageInfo] of Object.entries(vaadinBundleJson.packages)) { let installedVersion = void 0; try { const { version: bundledVersion } = packageInfo; const installedPackageJsonFile = path.resolve(modulesDirectory, name, "package.json"); const packageJson = JSON.parse(readFileSync4(installedPackageJsonFile, { encoding: "utf8" })); installedVersion = packageJson.version; if (installedVersion && installedVersion !== bundledVersion) { versionMismatches.push({ name, bundledVersion, installedVersion }); } } catch (_) { } } if (versionMismatches.length) { console.info(`@vaadin/bundles has version mismatches with installed packages, ${disabledMessage}`); console.info(`Packages with version mismatches: ${JSON.stringify(versionMismatches, void 0, 2)}`); vaadinBundleJson = { packages: {} }; return false; } return true; }, async config(config) { return mergeConfig( { optimizeDeps: { exclude: [ // Vaadin bundle "@vaadin/bundles", ...Object.keys(vaadinBundleJson.packages), "@vaadin/vaadin-material-styles" ] } }, config ); }, load(rawId) { const [path2, params] = rawId.split("?"); if (!path2.startsWith(modulesDirectory)) return; const id = path2.substring(modulesDirectory.length + 1); const bindings = getExports(id); if (bindings === void 0) return; const cacheSuffix = params ? `?${params}` : ""; const bundlePath = `@vaadin/bundles/vaadin.js${cacheSuffix}`; return `import { init as VaadinBundleInit, get as VaadinBundleGet } from '${bundlePath}'; await VaadinBundleInit('default'); const { ${bindings.map(getImportAssigment).join(", ")} } = (await VaadinBundleGet('./node_modules/${id}'))(); export { ${bindings.map(getExportBinding).join(", ")} };`; } }; } function themePlugin(opts) { const fullThemeOptions = { ...themeOptions, devMode: opts.devMode }; return { name: "vaadin:theme", config() { processThemeResources(fullThemeOptions, console); }, configureServer(server) { function handleThemeFileCreateDelete(themeFile, stats) { if (themeFile.startsWith(themeFolder)) { const changed = path.relative(themeFolder, themeFile); console.debug("Theme file " + (!!stats ? "created" : "deleted"), changed); processThemeResources(fullThemeOptions, console); } } server.watcher.on("add", handleThemeFileCreateDelete); server.watcher.on("unlink", handleThemeFileCreateDelete); }, handleHotUpdate(context) { const contextPath = path.resolve(context.file); const themePath = path.resolve(themeFolder); if (contextPath.startsWith(themePath)) { const changed = path.relative(themePath, contextPath); console.debug("Theme file changed", changed); if (changed.startsWith(vaadin_dev_server_settings_default.themeName)) { processThemeResources(fullThemeOptions, console); } } }, async resolveId(id, importer) { if (path.resolve(themeOptions.frontendGeneratedFolder, "theme.js") === importer && !existsSync5(path.resolve(themeOptions.frontendGeneratedFolder, id))) { console.debug("Generate theme file " + id + " not existing. Processing theme resource"); processThemeResources(fullThemeOptions, console); return; } if (!id.startsWith(vaadin_dev_server_settings_default.themeFolder)) { return; } for (const location of [themeResourceFolder, frontendFolder]) { const result = await this.resolve(path.resolve(location, id)); if (result) { return result; } } }, async transform(raw, id, options) { const [bareId, query] = id.split("?"); if (!bareId?.startsWith(themeFolder) && !bareId?.startsWith(themeOptions.themeResourceFolder) || !bareId?.endsWith(".css")) { return; } const [themeName] = bareId.substring(themeFolder.length + 1).split("/"); return rewriteCssUrls(raw, path.dirname(bareId), path.resolve(themeFolder, themeName), console, opts); } }; } function runWatchDog(watchDogPort, watchDogHost) { const client = net.Socket(); client.setEncoding("utf8"); client.on("error", function(err) { console.log("Watchdog connection error. Terminating vite process...", err); client.destroy(); process.exit(0); }); client.on("close", function() { client.destroy(); runWatchDog(watchDogPort, watchDogHost); }); client.connect(watchDogPort, watchDogHost || "localhost"); } var allowedFrontendFolders = [frontendFolder, nodeModulesFolder]; function showRecompileReason() { return { name: "vaadin:why-you-compile", handleHotUpdate(context) { console.log("Recompiling because", context.file, "changed"); } }; } var DEV_MODE_START_REGEXP = /\/\*[\*!]\s+vaadin-dev-mode:start/; var DEV_MODE_CODE_REGEXP = /\/\*[\*!]\s+vaadin-dev-mode:start([\s\S]*)vaadin-dev-mode:end\s+\*\*\//i; function preserveUsageStats() { return { name: "vaadin:preserve-usage-stats", transform(src, id) { if (id.includes("vaadin-usage-statistics")) { if (src.includes("vaadin-dev-mode:start")) { const newSrc = src.replace(DEV_MODE_START_REGEXP, "/*! vaadin-dev-mode:start"); if (newSrc === src) { console.error("Comment replacement failed to change anything"); } else if (!newSrc.match(DEV_MODE_CODE_REGEXP)) { console.error("New comment fails to match original regexp"); } else { return { code: newSrc }; } } } return { code: src }; } }; } var vaadinConfig = (env) => { const devMode = env.mode === "development"; const productionMode = !devMode && !devBundle; if (devMode && process.env.watchDogPort) { runWatchDog(process.env.watchDogPort, process.env.watchDogHost); } return { root: frontendFolder, base: "", publicDir: false, resolve: { alias: { "@vaadin/flow-frontend": jarResourcesFolder, Frontend: frontendFolder }, preserveSymlinks: true }, define: { OFFLINE_PATH: vaadin_dev_server_settings_default.offlinePath, VITE_ENABLED: "true" }, server: { host: "127.0.0.1", strictPort: true, fs: { allow: allowedFrontendFolders } }, build: { outDir: buildOutputFolder, emptyOutDir: devBundle, assetsDir: "VAADIN/build", rollupOptions: { input: { indexhtml: projectIndexHtml, ...hasExportedWebComponents ? { webcomponenthtml: path.resolve(frontendFolder, "web-component.html") } : {} }, onwarn: (warning, defaultHandler) => { const ignoreEvalWarning = [ "generated/jar-resources/FlowClient.js", "generated/jar-resources/vaadin-spreadsheet/spreadsheet-export.js", "@vaadin/charts/src/helpers.js" ]; if (warning.code === "EVAL" && warning.id && !!ignoreEvalWarning.find((id) => warning.id.endsWith(id))) { return; } defaultHandler(warning); } } }, optimizeDeps: { entries: [ // Pre-scan entrypoints in Vite to avoid reloading on first open "generated/vaadin.ts" ], exclude: [ "@vaadin/router", "@vaadin/vaadin-license-checker", "@vaadin/vaadin-usage-statistics", "workbox-core", "workbox-precaching", "workbox-routing", "workbox-strategies" ] }, plugins: [ productionMode && brotli(), devMode && vaadinBundlesPlugin(), devMode && showRecompileReason(), vaadin_dev_server_settings_default.offlineEnabled && buildSWPlugin({ devMode }), !devMode && statsExtracterPlugin(), devBundle && preserveUsageStats(), themePlugin({ devMode }), postcssLit({ include: ["**/*.css", /.*\/.*\.css\?.*/], exclude: [ `${themeFolder}/**/*.css`, new RegExp(`${themeFolder}/.*/.*\\.css\\?.*`), `${themeResourceFolder}/**/*.css`, new RegExp(`${themeResourceFolder}/.*/.*\\.css\\?.*`), new RegExp(".*/.*\\?html-proxy.*") ] }), { name: "vaadin:force-remove-html-middleware", configureServer(server) { return () => { server.middlewares.stack = server.middlewares.stack.filter((mw) => { const handleName = `${mw.handle}`; return !handleName.includes("viteHtmlFallbackMiddleware"); }); }; } }, hasExportedWebComponents && { name: "vaadin:inject-entrypoints-to-web-component-html", transformIndexHtml: { order: "pre", handler(_html, { path: path2, server }) { if (path2 !== "/web-component.html") { return; } return [ { tag: "script", attrs: { type: "module", src: `/generated/vaadin-web-component.ts` }, injectTo: "head" } ]; } } }, { name: "vaadin:inject-entrypoints-to-index-html", transformIndexHtml: { order: "pre", handler(_html, { path: path2, server }) { if (path2 !== "/index.html") { return; } const scripts = []; if (devMode) { scripts.push({ tag: "script", attrs: { type: "module", src: `/generated/vite-devmode.ts` }, injectTo: "head" }); } scripts.push({ tag: "script", attrs: { type: "module", src: "/generated/vaadin.ts" }, injectTo: "head" }); return scripts; } } }, checker({ typescript: true }), productionMode && visualizer({ brotliSize: true, filename: bundleSizeFile }) ] }; }; var overrideVaadinConfig = (customConfig2) => { return defineConfig((env) => mergeConfig(vaadinConfig(env), customConfig2(env))); }; function getVersion(module) { const packageJson = path.resolve(nodeModulesFolder, module, "package.json"); return JSON.parse(readFileSync4(packageJson, { encoding: "utf-8" })).version; } function getCvdlName(module) { const packageJson = path.resolve(nodeModulesFolder, module, "package.json"); return JSON.parse(readFileSync4(packageJson, { encoding: "utf-8" })).cvdlName; } // vite.config.ts var customConfig = (env) => ({ // Here you can add custom Vite parameters // https://vitejs.dev/config/ }); var vite_config_default = overrideVaadinConfig(customConfig); export { vite_config_default as default }; //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["vite.generated.ts", "target/plugins/application-theme-plugin/theme-handle.js", "target/plugins/application-theme-plugin/theme-generator.js", "target/plugins/application-theme-plugin/theme-copy.js", "target/plugins/theme-loader/theme-loader-utils.js", "target/vaadin-dev-server-settings.json", "target/plugins/rollup-plugin-postcss-lit-custom/rollup-plugin-postcss-lit.js", "vite.config.ts"],
  "sourcesContent": ["const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\vite.generated.ts\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/vite.generated.ts\";/**\n * NOTICE: this is an auto-generated file\n *\n * This file has been generated by the `flow:prepare-frontend` maven goal.\n * This file will be overwritten on every run. Any custom changes should be made to vite.config.ts\n */\nimport path from 'path';\nimport { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';\nimport { createHash } from 'crypto';\nimport * as net from 'net';\n\nimport { processThemeResources } from './target/plugins/application-theme-plugin/theme-handle.js';\nimport { rewriteCssUrls } from './target/plugins/theme-loader/theme-loader-utils.js';\nimport settings from './target/vaadin-dev-server-settings.json';\nimport {\n  AssetInfo,\n  ChunkInfo,\n  defineConfig,\n  mergeConfig,\n  OutputOptions,\n  PluginOption,\n  ResolvedConfig,\n  UserConfigFn\n} from 'vite';\nimport { getManifest } from 'workbox-build';\n\nimport * as rollup from 'rollup';\nimport brotli from 'rollup-plugin-brotli';\nimport replace from '@rollup/plugin-replace';\nimport checker from 'vite-plugin-checker';\nimport postcssLit from './target/plugins/rollup-plugin-postcss-lit-custom/rollup-plugin-postcss-lit.js';\n\nimport { createRequire } from 'module';\n\nimport { visualizer } from 'rollup-plugin-visualizer';\n\n// Make `require` compatible with ES modules\nconst require = createRequire(import.meta.url);\n\nconst appShellUrl = '.';\n\nconst frontendFolder = path.resolve(__dirname, settings.frontendFolder);\nconst themeFolder = path.resolve(frontendFolder, settings.themeFolder);\nconst frontendBundleFolder = path.resolve(__dirname, settings.frontendBundleOutput);\nconst devBundleFolder = path.resolve(__dirname, settings.devBundleOutput);\nconst devBundle = !!process.env.devBundle;\nconst jarResourcesFolder = path.resolve(__dirname, settings.jarResourcesFolder);\nconst themeResourceFolder = path.resolve(__dirname, settings.themeResourceFolder);\nconst projectPackageJsonFile = path.resolve(__dirname, 'package.json');\n\nconst buildOutputFolder = devBundle ? devBundleFolder : frontendBundleFolder;\nconst statsFolder = path.resolve(__dirname, devBundle ? settings.devBundleStatsOutput : settings.statsOutput);\nconst statsFile = path.resolve(statsFolder, 'stats.json');\nconst bundleSizeFile = path.resolve(statsFolder, 'bundle-size.html');\nconst nodeModulesFolder = path.resolve(__dirname, 'node_modules');\nconst webComponentTags = '';\n\nconst projectIndexHtml = path.resolve(frontendFolder, 'index.html');\n\nconst projectStaticAssetsFolders = [\n  path.resolve(__dirname, 'src', 'main', 'resources', 'META-INF', 'resources'),\n  path.resolve(__dirname, 'src', 'main', 'resources', 'static'),\n  frontendFolder\n];\n\n// Folders in the project which can contain application themes\nconst themeProjectFolders = projectStaticAssetsFolders.map((folder) => path.resolve(folder, settings.themeFolder));\n\nconst themeOptions = {\n  devMode: false,\n  useDevBundle: devBundle,\n  // The following matches folder 'frontend/generated/themes/'\n  // (not 'frontend/themes') for theme in JAR that is copied there\n  themeResourceFolder: path.resolve(themeResourceFolder, settings.themeFolder),\n  themeProjectFolders: themeProjectFolders,\n  projectStaticAssetsOutputFolder: devBundle\n    ? path.resolve(devBundleFolder, '../assets')\n    : path.resolve(__dirname, settings.staticOutput),\n  frontendGeneratedFolder: path.resolve(frontendFolder, settings.generatedFolder)\n};\n\nconst hasExportedWebComponents = existsSync(path.resolve(frontendFolder, 'web-component.html'));\n\n// Block debug and trace logs.\nconsole.trace = () => {};\nconsole.debug = () => {};\n\nfunction injectManifestToSWPlugin(): rollup.Plugin {\n  const rewriteManifestIndexHtmlUrl = (manifest) => {\n    const indexEntry = manifest.find((entry) => entry.url === 'index.html');\n    if (indexEntry) {\n      indexEntry.url = appShellUrl;\n    }\n\n    return { manifest, warnings: [] };\n  };\n\n  return {\n    name: 'vaadin:inject-manifest-to-sw',\n    async transform(code, id) {\n      if (/sw\\.(ts|js)$/.test(id)) {\n        const { manifestEntries } = await getManifest({\n          globDirectory: buildOutputFolder,\n          globPatterns: ['**/*'],\n          globIgnores: ['**/*.br'],\n          manifestTransforms: [rewriteManifestIndexHtmlUrl],\n          maximumFileSizeToCacheInBytes: 100 * 1024 * 1024 // 100mb,\n        });\n\n        return code.replace('self.__WB_MANIFEST', JSON.stringify(manifestEntries));\n      }\n    }\n  };\n}\n\nfunction buildSWPlugin(opts): PluginOption {\n  let config: ResolvedConfig;\n  const devMode = opts.devMode;\n\n  const swObj = {};\n\n  async function build(action: 'generate' | 'write', additionalPlugins: rollup.Plugin[] = []) {\n    const includedPluginNames = [\n      'vite:esbuild',\n      'rollup-plugin-dynamic-import-variables',\n      'vite:esbuild-transpile',\n      'vite:terser'\n    ];\n    const plugins: rollup.Plugin[] = config.plugins.filter((p) => {\n      return includedPluginNames.includes(p.name);\n    });\n    const resolver = config.createResolver();\n    const resolvePlugin: rollup.Plugin = {\n      name: 'resolver',\n      resolveId(source, importer, _options) {\n        return resolver(source, importer);\n      }\n    };\n    plugins.unshift(resolvePlugin); // Put resolve first\n    plugins.push(\n      replace({\n        values: {\n          'process.env.NODE_ENV': JSON.stringify(config.mode),\n          ...config.define\n        },\n        preventAssignment: true\n      })\n    );\n    if (additionalPlugins) {\n      plugins.push(...additionalPlugins);\n    }\n    const bundle = await rollup.rollup({\n      input: path.resolve(settings.clientServiceWorkerSource),\n      plugins\n    });\n\n    try {\n      return await bundle[action]({\n        file: path.resolve(buildOutputFolder, 'sw.js'),\n        format: 'es',\n        exports: 'none',\n        sourcemap: config.command === 'serve' || config.build.sourcemap,\n        inlineDynamicImports: true\n      });\n    } finally {\n      await bundle.close();\n    }\n  }\n\n  return {\n    name: 'vaadin:build-sw',\n    enforce: 'post',\n    async configResolved(resolvedConfig) {\n      config = resolvedConfig;\n    },\n    async buildStart() {\n      if (devMode) {\n        const { output } = await build('generate');\n        swObj.code = output[0].code;\n        swObj.map = output[0].map;\n      }\n    },\n    async load(id) {\n      if (id.endsWith('sw.js')) {\n        return '';\n      }\n    },\n    async transform(_code, id) {\n      if (id.endsWith('sw.js')) {\n        return swObj;\n      }\n    },\n    async closeBundle() {\n      if (!devMode) {\n        await build('write', [injectManifestToSWPlugin(), brotli()]);\n      }\n    }\n  };\n}\n\nfunction statsExtracterPlugin(): PluginOption {\n  function collectThemeJsonsInFrontend(themeJsonContents: Record<string, string>, themeName: string) {\n    const themeJson = path.resolve(frontendFolder, settings.themeFolder, themeName, 'theme.json');\n    if (existsSync(themeJson)) {\n      const themeJsonContent = readFileSync(themeJson, { encoding: 'utf-8' }).replace(/\\r\\n/g, '\\n');\n      themeJsonContents[themeName] = themeJsonContent;\n      const themeJsonObject = JSON.parse(themeJsonContent);\n      if (themeJsonObject.parent) {\n        collectThemeJsonsInFrontend(themeJsonContents, themeJsonObject.parent);\n      }\n    }\n  }\n\n  return {\n    name: 'vaadin:stats',\n    enforce: 'post',\n    async writeBundle(options: OutputOptions, bundle: { [fileName: string]: AssetInfo | ChunkInfo }) {\n      const modules = Object.values(bundle).flatMap((b) => (b.modules ? Object.keys(b.modules) : []));\n      const nodeModulesFolders = modules\n        .map((id) => id.replace(/\\\\/g, '/'))\n        .filter((id) => id.startsWith(nodeModulesFolder.replace(/\\\\/g, '/')))\n        .map((id) => id.substring(nodeModulesFolder.length + 1));\n      const npmModules = nodeModulesFolders\n        .map((id) => id.replace(/\\\\/g, '/'))\n        .map((id) => {\n          const parts = id.split('/');\n          if (id.startsWith('@')) {\n            return parts[0] + '/' + parts[1];\n          } else {\n            return parts[0];\n          }\n        })\n        .sort()\n        .filter((value, index, self) => self.indexOf(value) === index);\n      const npmModuleAndVersion = Object.fromEntries(npmModules.map((module) => [module, getVersion(module)]));\n      const cvdls = Object.fromEntries(\n        npmModules\n          .filter((module) => getCvdlName(module) != null)\n          .map((module) => [module, { name: getCvdlName(module), version: getVersion(module) }])\n      );\n\n      mkdirSync(path.dirname(statsFile), { recursive: true });\n      const projectPackageJson = JSON.parse(readFileSync(projectPackageJsonFile, { encoding: 'utf-8' }));\n\n      const entryScripts = Object.values(bundle)\n        .filter((bundle) => bundle.isEntry)\n        .map((bundle) => bundle.fileName);\n\n      const generatedIndexHtml = path.resolve(buildOutputFolder, 'index.html');\n      const customIndexData: string = readFileSync(projectIndexHtml, { encoding: 'utf-8' });\n      const generatedIndexData: string = readFileSync(generatedIndexHtml, {\n        encoding: 'utf-8'\n      });\n\n      const customIndexRows = new Set(customIndexData.split(/[\\r\\n]/).filter((row) => row.trim() !== ''));\n      const generatedIndexRows = generatedIndexData.split(/[\\r\\n]/).filter((row) => row.trim() !== '');\n\n      const rowsGenerated: string[] = [];\n      generatedIndexRows.forEach((row) => {\n        if (!customIndexRows.has(row)) {\n          rowsGenerated.push(row);\n        }\n      });\n\n      //After dev-bundle build add used Flow frontend imports JsModule/JavaScript/CssImport\n\n      const parseImports = (filename: string, result: Set<string>): void => {\n        const content: string = readFileSync(filename, { encoding: 'utf-8' });\n        const lines = content.split('\\n');\n        const staticImports = lines\n          .filter((line) => line.startsWith('import '))\n          .map((line) => line.substring(line.indexOf(\"'\") + 1, line.lastIndexOf(\"'\")))\n          .map((line) => (line.includes('?') ? line.substring(0, line.lastIndexOf('?')) : line));\n        const dynamicImports = lines\n          .filter((line) => line.includes('import('))\n          .map((line) => line.replace(/.*import\\(/, ''))\n          .map((line) => line.split(/'/)[1])\n          .map((line) => (line.includes('?') ? line.substring(0, line.lastIndexOf('?')) : line));\n\n        staticImports.forEach((staticImport) => result.add(staticImport));\n\n        dynamicImports.map((dynamicImport) => {\n          const importedFile = path.resolve(path.dirname(filename), dynamicImport);\n          parseImports(importedFile, result);\n        });\n      };\n\n      const generatedImportsSet = new Set<string>();\n      parseImports(\n        path.resolve(themeOptions.frontendGeneratedFolder, 'flow', 'generated-flow-imports.js'),\n        generatedImportsSet\n      );\n      const generatedImports = Array.from(generatedImportsSet).sort();\n\n      const frontendFiles: Record<string, string> = {};\n\n      const projectFileExtensions = ['.js', '.js.map', '.ts', '.ts.map', '.tsx', '.tsx.map', '.css', '.css.map'];\n\n      const isThemeComponentsResource = (id: string) =>\n          id.startsWith(themeOptions.frontendGeneratedFolder.replace(/\\\\/g, '/'))\n              && id.match(/.*\\/jar-resources\\/themes\\/[^\\/]+\\/components\\//);\n\n      const isGeneratedWebComponentResource = (id: string) =>\n          id.startsWith(themeOptions.frontendGeneratedFolder.replace(/\\\\/g, '/'))\n              && id.match(/.*\\/flow\\/web-components\\//);\n\n      const isFrontendResourceCollected = (id: string) =>\n          !id.startsWith(themeOptions.frontendGeneratedFolder.replace(/\\\\/g, '/'))\n          || isThemeComponentsResource(id) \n          || isGeneratedWebComponentResource(id);\n\n      // collects project's frontend resources in frontend folder, excluding\n      // 'generated' sub-folder, except for legacy shadow DOM stylesheets\n      // packaged in `theme/components/` folder\n      // and generated web component resources in `flow/web-components` folder.\n      modules\n        .map((id) => id.replace(/\\\\/g, '/'))\n        .filter((id) => id.startsWith(frontendFolder.replace(/\\\\/g, '/')))\n        .filter(isFrontendResourceCollected)\n        .map((id) => id.substring(frontendFolder.length + 1))\n        .map((line: string) => (line.includes('?') ? line.substring(0, line.lastIndexOf('?')) : line))\n        .forEach((line: string) => {\n          // \\r\\n from windows made files may be used so change to \\n\n          const filePath = path.resolve(frontendFolder, line);\n          if (projectFileExtensions.includes(path.extname(filePath))) {\n            const fileBuffer = readFileSync(filePath, { encoding: 'utf-8' }).replace(/\\r\\n/g, '\\n');\n            frontendFiles[line] = createHash('sha256').update(fileBuffer, 'utf8').digest('hex');\n          }\n        });\n\n      // collects frontend resources from the JARs\n      generatedImports\n        .filter((line: string) => line.includes('generated/jar-resources'))\n        .forEach((line: string) => {\n          let filename = line.substring(line.indexOf('generated'));\n          // \\r\\n from windows made files may be used ro remove to be only \\n\n          const fileBuffer = readFileSync(path.resolve(frontendFolder, filename), { encoding: 'utf-8' }).replace(\n            /\\r\\n/g,\n            '\\n'\n          );\n          const hash = createHash('sha256').update(fileBuffer, 'utf8').digest('hex');\n\n          const fileKey = line.substring(line.indexOf('jar-resources/') + 14);\n          frontendFiles[fileKey] = hash;\n        });\n      // collects and hash rest of the Frontend resources excluding files in /generated/ and /themes/ \n      // and files already in frontendFiles.\n      let frontendFolderAlias = \"Frontend\";\n      generatedImports\n        .filter((line: string) => line.startsWith(frontendFolderAlias + '/'))\n        .filter((line: string) => !line.startsWith(frontendFolderAlias + '/generated/'))\n        .filter((line: string) => !line.startsWith(frontendFolderAlias + '/themes/'))\n        .map((line) => line.substring(frontendFolderAlias.length + 1))\n        .filter((line: string) => !frontendFiles[line])\n        .forEach((line: string) => {\n          const filePath = path.resolve(frontendFolder, line);\n          if (projectFileExtensions.includes(path.extname(filePath)) && existsSync(filePath)) {\n            const fileBuffer = readFileSync(filePath, { encoding: 'utf-8' }).replace(/\\r\\n/g, '\\n');\n            frontendFiles[line] = createHash('sha256').update(fileBuffer, 'utf8').digest('hex');\n          }\n        });        \n      // If a index.ts exists hash it to be able to see if it changes.\n      if (existsSync(path.resolve(frontendFolder, 'index.ts'))) {\n        const fileBuffer = readFileSync(path.resolve(frontendFolder, 'index.ts'), { encoding: 'utf-8' }).replace(\n          /\\r\\n/g,\n          '\\n'\n        );\n        frontendFiles[`index.ts`] = createHash('sha256').update(fileBuffer, 'utf8').digest('hex');\n      }\n\n      const themeJsonContents: Record<string, string> = {};\n      const themesFolder = path.resolve(jarResourcesFolder, 'themes');\n      if (existsSync(themesFolder)) {\n        readdirSync(themesFolder).forEach((themeFolder) => {\n          const themeJson = path.resolve(themesFolder, themeFolder, 'theme.json');\n          if (existsSync(themeJson)) {\n            themeJsonContents[path.basename(themeFolder)] = readFileSync(themeJson, { encoding: 'utf-8' }).replace(\n              /\\r\\n/g,\n              '\\n'\n            );\n          }\n        });\n      }\n\n      collectThemeJsonsInFrontend(themeJsonContents, settings.themeName);\n\n      let webComponents: string[] = [];\n      if (webComponentTags) {\n        webComponents = webComponentTags.split(';');\n      }\n\n      const stats = {\n        packageJsonDependencies: projectPackageJson.dependencies,\n        npmModules: npmModuleAndVersion,\n        bundleImports: generatedImports,\n        frontendHashes: frontendFiles,\n        themeJsonContents: themeJsonContents,\n        entryScripts,\n        webComponents,\n        cvdlModules: cvdls,\n        packageJsonHash: projectPackageJson?.vaadin?.hash,\n        indexHtmlGenerated: rowsGenerated\n      };\n      writeFileSync(statsFile, JSON.stringify(stats, null, 1));\n    }\n  };\n}\nfunction vaadinBundlesPlugin(): PluginOption {\n  type ExportInfo =\n    | string\n    | {\n        namespace?: string;\n        source: string;\n      };\n\n  type ExposeInfo = {\n    exports: ExportInfo[];\n  };\n\n  type PackageInfo = {\n    version: string;\n    exposes: Record<string, ExposeInfo>;\n  };\n\n  type BundleJson = {\n    packages: Record<string, PackageInfo>;\n  };\n\n  const disabledMessage = 'Vaadin component dependency bundles are disabled.';\n\n  const modulesDirectory = nodeModulesFolder.replace(/\\\\/g, '/');\n\n  let vaadinBundleJson: BundleJson;\n\n  function parseModuleId(id: string): { packageName: string; modulePath: string } {\n    const [scope, scopedPackageName] = id.split('/', 3);\n    const packageName = scope.startsWith('@') ? `${scope}/${scopedPackageName}` : scope;\n    const modulePath = `.${id.substring(packageName.length)}`;\n    return {\n      packageName,\n      modulePath\n    };\n  }\n\n  function getExports(id: string): string[] | undefined {\n    const { packageName, modulePath } = parseModuleId(id);\n    const packageInfo = vaadinBundleJson.packages[packageName];\n\n    if (!packageInfo) return;\n\n    const exposeInfo: ExposeInfo = packageInfo.exposes[modulePath];\n    if (!exposeInfo) return;\n\n    const exportsSet = new Set<string>();\n    for (const e of exposeInfo.exports) {\n      if (typeof e === 'string') {\n        exportsSet.add(e);\n      } else {\n        const { namespace, source } = e;\n        if (namespace) {\n          exportsSet.add(namespace);\n        } else {\n          const sourceExports = getExports(source);\n          if (sourceExports) {\n            sourceExports.forEach((e) => exportsSet.add(e));\n          }\n        }\n      }\n    }\n    return Array.from(exportsSet);\n  }\n\n  function getExportBinding(binding: string) {\n    return binding === 'default' ? '_default as default' : binding;\n  }\n\n  function getImportAssigment(binding: string) {\n    return binding === 'default' ? 'default: _default' : binding;\n  }\n\n  return {\n    name: 'vaadin:bundles',\n    enforce: 'pre',\n    apply(config, { command }) {\n      if (command !== 'serve') return false;\n\n      try {\n        const vaadinBundleJsonPath = require.resolve('@vaadin/bundles/vaadin-bundle.json');\n        vaadinBundleJson = JSON.parse(readFileSync(vaadinBundleJsonPath, { encoding: 'utf8' }));\n      } catch (e: unknown) {\n        if (typeof e === 'object' && (e as { code: string }).code === 'MODULE_NOT_FOUND') {\n          vaadinBundleJson = { packages: {} };\n          console.info(`@vaadin/bundles npm package is not found, ${disabledMessage}`);\n          return false;\n        } else {\n          throw e;\n        }\n      }\n\n      const versionMismatches: Array<{ name: string; bundledVersion: string; installedVersion: string }> = [];\n      for (const [name, packageInfo] of Object.entries(vaadinBundleJson.packages)) {\n        let installedVersion: string | undefined = undefined;\n        try {\n          const { version: bundledVersion } = packageInfo;\n          const installedPackageJsonFile = path.resolve(modulesDirectory, name, 'package.json');\n          const packageJson = JSON.parse(readFileSync(installedPackageJsonFile, { encoding: 'utf8' }));\n          installedVersion = packageJson.version;\n          if (installedVersion && installedVersion !== bundledVersion) {\n            versionMismatches.push({\n              name,\n              bundledVersion,\n              installedVersion\n            });\n          }\n        } catch (_) {\n          // ignore package not found\n        }\n      }\n      if (versionMismatches.length) {\n        console.info(`@vaadin/bundles has version mismatches with installed packages, ${disabledMessage}`);\n        console.info(`Packages with version mismatches: ${JSON.stringify(versionMismatches, undefined, 2)}`);\n        vaadinBundleJson = { packages: {} };\n        return false;\n      }\n\n      return true;\n    },\n    async config(config) {\n      return mergeConfig(\n        {\n          optimizeDeps: {\n            exclude: [\n              // Vaadin bundle\n              '@vaadin/bundles',\n              ...Object.keys(vaadinBundleJson.packages),\n              '@vaadin/vaadin-material-styles'\n            ]\n          }\n        },\n        config\n      );\n    },\n    load(rawId) {\n      const [path, params] = rawId.split('?');\n      if (!path.startsWith(modulesDirectory)) return;\n\n      const id = path.substring(modulesDirectory.length + 1);\n      const bindings = getExports(id);\n      if (bindings === undefined) return;\n\n      const cacheSuffix = params ? `?${params}` : '';\n      const bundlePath = `@vaadin/bundles/vaadin.js${cacheSuffix}`;\n\n      return `import { init as VaadinBundleInit, get as VaadinBundleGet } from '${bundlePath}';\nawait VaadinBundleInit('default');\nconst { ${bindings.map(getImportAssigment).join(', ')} } = (await VaadinBundleGet('./node_modules/${id}'))();\nexport { ${bindings.map(getExportBinding).join(', ')} };`;\n    }\n  };\n}\n\nfunction themePlugin(opts): PluginOption {\n  const fullThemeOptions = { ...themeOptions, devMode: opts.devMode };\n  return {\n    name: 'vaadin:theme',\n    config() {\n      processThemeResources(fullThemeOptions, console);\n    },\n    configureServer(server) {\n      function handleThemeFileCreateDelete(themeFile, stats) {\n        if (themeFile.startsWith(themeFolder)) {\n          const changed = path.relative(themeFolder, themeFile);\n          console.debug('Theme file ' + (!!stats ? 'created' : 'deleted'), changed);\n          processThemeResources(fullThemeOptions, console);\n        }\n      }\n      server.watcher.on('add', handleThemeFileCreateDelete);\n      server.watcher.on('unlink', handleThemeFileCreateDelete);\n    },\n    handleHotUpdate(context) {\n      const contextPath = path.resolve(context.file);\n      const themePath = path.resolve(themeFolder);\n      if (contextPath.startsWith(themePath)) {\n        const changed = path.relative(themePath, contextPath);\n\n        console.debug('Theme file changed', changed);\n\n        if (changed.startsWith(settings.themeName)) {\n          processThemeResources(fullThemeOptions, console);\n        }\n      }\n    },\n    async resolveId(id, importer) {\n      // force theme generation if generated theme sources does not yet exist\n      // this may happen for example during Java hot reload when updating\n      // @Theme annotation value\n      if (\n        path.resolve(themeOptions.frontendGeneratedFolder, 'theme.js') === importer &&\n        !existsSync(path.resolve(themeOptions.frontendGeneratedFolder, id))\n      ) {\n        console.debug('Generate theme file ' + id + ' not existing. Processing theme resource');\n        processThemeResources(fullThemeOptions, console);\n        return;\n      }\n      if (!id.startsWith(settings.themeFolder)) {\n        return;\n      }\n\n      for (const location of [themeResourceFolder, frontendFolder]) {\n        const result = await this.resolve(path.resolve(location, id));\n        if (result) {\n          return result;\n        }\n      }\n    },\n    async transform(raw, id, options) {\n      // rewrite urls for the application theme css files\n      const [bareId, query] = id.split('?');\n      if (\n        (!bareId?.startsWith(themeFolder) && !bareId?.startsWith(themeOptions.themeResourceFolder)) ||\n        !bareId?.endsWith('.css')\n      ) {\n        return;\n      }\n      const [themeName] = bareId.substring(themeFolder.length + 1).split('/');\n      return rewriteCssUrls(raw, path.dirname(bareId), path.resolve(themeFolder, themeName), console, opts);\n    }\n  };\n}\n\nfunction runWatchDog(watchDogPort, watchDogHost) {\n  const client = net.Socket();\n  client.setEncoding('utf8');\n  client.on('error', function (err) {\n    console.log('Watchdog connection error. Terminating vite process...', err);\n    client.destroy();\n    process.exit(0);\n  });\n  client.on('close', function () {\n    client.destroy();\n    runWatchDog(watchDogPort, watchDogHost);\n  });\n\n  client.connect(watchDogPort, watchDogHost || 'localhost');\n}\n\nconst allowedFrontendFolders = [frontendFolder, nodeModulesFolder];\n\nfunction showRecompileReason(): PluginOption {\n  return {\n    name: 'vaadin:why-you-compile',\n    handleHotUpdate(context) {\n      console.log('Recompiling because', context.file, 'changed');\n    }\n  };\n}\n\nconst DEV_MODE_START_REGEXP = /\\/\\*[\\*!]\\s+vaadin-dev-mode:start/;\nconst DEV_MODE_CODE_REGEXP = /\\/\\*[\\*!]\\s+vaadin-dev-mode:start([\\s\\S]*)vaadin-dev-mode:end\\s+\\*\\*\\//i;\n\nfunction preserveUsageStats() {\n  return {\n    name: 'vaadin:preserve-usage-stats',\n\n    transform(src: string, id: string) {\n      if (id.includes('vaadin-usage-statistics')) {\n        if (src.includes('vaadin-dev-mode:start')) {\n          const newSrc = src.replace(DEV_MODE_START_REGEXP, '/*! vaadin-dev-mode:start');\n          if (newSrc === src) {\n            console.error('Comment replacement failed to change anything');\n          } else if (!newSrc.match(DEV_MODE_CODE_REGEXP)) {\n            console.error('New comment fails to match original regexp');\n          } else {\n            return { code: newSrc };\n          }\n        }\n      }\n\n      return { code: src };\n    }\n  };\n}\n\nexport const vaadinConfig: UserConfigFn = (env) => {\n  const devMode = env.mode === 'development';\n  const productionMode = !devMode && !devBundle\n\n  if (devMode && process.env.watchDogPort) {\n    // Open a connection with the Java dev-mode handler in order to finish\n    // vite when it exits or crashes.\n    runWatchDog(process.env.watchDogPort, process.env.watchDogHost);\n  }\n\n  return {\n    root: frontendFolder,\n    base: '',\n    publicDir: false,\n    resolve: {\n      alias: {\n        '@vaadin/flow-frontend': jarResourcesFolder,\n        Frontend: frontendFolder\n      },\n      preserveSymlinks: true\n    },\n    define: {\n      OFFLINE_PATH: settings.offlinePath,\n      VITE_ENABLED: 'true'\n    },\n    server: {\n      host: '127.0.0.1',\n      strictPort: true,\n      fs: {\n        allow: allowedFrontendFolders\n      }\n    },\n    build: {\n      outDir: buildOutputFolder,\n      emptyOutDir: devBundle,\n      assetsDir: 'VAADIN/build',\n      rollupOptions: {\n        input: {\n          indexhtml: projectIndexHtml,\n\n          ...(hasExportedWebComponents ? { webcomponenthtml: path.resolve(frontendFolder, 'web-component.html') } : {})\n        },\n        onwarn: (warning: rollup.RollupWarning, defaultHandler: rollup.WarningHandler) => {\n          const ignoreEvalWarning = [\n            'generated/jar-resources/FlowClient.js',\n            'generated/jar-resources/vaadin-spreadsheet/spreadsheet-export.js',\n            '@vaadin/charts/src/helpers.js'\n          ];\n          if (warning.code === 'EVAL' && warning.id && !!ignoreEvalWarning.find((id) => warning.id.endsWith(id))) {\n            return;\n          }\n          defaultHandler(warning);\n        }\n      }\n    },\n    optimizeDeps: {\n      entries: [\n        // Pre-scan entrypoints in Vite to avoid reloading on first open\n        'generated/vaadin.ts'\n      ],\n      exclude: [\n        '@vaadin/router',\n        '@vaadin/vaadin-license-checker',\n        '@vaadin/vaadin-usage-statistics',\n        'workbox-core',\n        'workbox-precaching',\n        'workbox-routing',\n        'workbox-strategies'\n      ]\n    },\n    plugins: [\n      productionMode && brotli(),\n      devMode && vaadinBundlesPlugin(),\n      devMode && showRecompileReason(),\n      settings.offlineEnabled && buildSWPlugin({ devMode }),\n      !devMode && statsExtracterPlugin(),\n      devBundle && preserveUsageStats(),\n      themePlugin({ devMode }),\n      postcssLit({\n        include: ['**/*.css', /.*\\/.*\\.css\\?.*/],\n        exclude: [\n          `${themeFolder}/**/*.css`,\n          new RegExp(`${themeFolder}/.*/.*\\\\.css\\\\?.*`),\n          `${themeResourceFolder}/**/*.css`,\n          new RegExp(`${themeResourceFolder}/.*/.*\\\\.css\\\\?.*`),\n          new RegExp('.*/.*\\\\?html-proxy.*')\n        ]\n      }),\n      {\n        name: 'vaadin:force-remove-html-middleware',\n        configureServer(server) {\n          return () => {\n            server.middlewares.stack = server.middlewares.stack.filter((mw) => {\n              const handleName = `${mw.handle}`;\n              return !handleName.includes('viteHtmlFallbackMiddleware');\n            });\n          };\n        },\n      },\n      hasExportedWebComponents && {\n        name: 'vaadin:inject-entrypoints-to-web-component-html',\n        transformIndexHtml: {\n          order: 'pre',\n          handler(_html, { path, server }) {\n            if (path !== '/web-component.html') {\n              return;\n            }\n\n            return [\n              {\n                tag: 'script',\n                attrs: { type: 'module', src: `/generated/vaadin-web-component.ts` },\n                injectTo: 'head'\n              }\n            ];\n          }\n        }\n      },\n      {\n        name: 'vaadin:inject-entrypoints-to-index-html',\n        transformIndexHtml: {\n          order: 'pre',\n          handler(_html, { path, server }) {\n            if (path !== '/index.html') {\n              return;\n            }\n\n            const scripts = [];\n\n            if (devMode) {\n              scripts.push({\n                tag: 'script',\n                attrs: { type: 'module', src: `/generated/vite-devmode.ts` },\n                injectTo: 'head'\n              });\n            }\n            scripts.push({\n              tag: 'script',\n              attrs: { type: 'module', src: '/generated/vaadin.ts' },\n              injectTo: 'head'\n            });\n            return scripts;\n          }\n        }\n      },\n      checker({\n        typescript: true\n      }),\n      productionMode && visualizer({ brotliSize: true, filename: bundleSizeFile })\n    ]\n  };\n};\n\nexport const overrideVaadinConfig = (customConfig: UserConfigFn) => {\n  return defineConfig((env) => mergeConfig(vaadinConfig(env), customConfig(env)));\n};\nfunction getVersion(module: string): string {\n  const packageJson = path.resolve(nodeModulesFolder, module, 'package.json');\n  return JSON.parse(readFileSync(packageJson, { encoding: 'utf-8' })).version;\n}\nfunction getCvdlName(module: string): string {\n  const packageJson = path.resolve(nodeModulesFolder, module, 'package.json');\n  return JSON.parse(readFileSync(packageJson, { encoding: 'utf-8' })).cvdlName;\n}\n", "const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\application-theme-plugin\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\application-theme-plugin\\\\theme-handle.js\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/plugins/application-theme-plugin/theme-handle.js\";/*\n * Copyright 2000-2023 Vaadin Ltd.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\n/**\n * This file contains functions for look up and handle the theme resources\n * for application theme plugin.\n */\nimport { existsSync, readFileSync } from 'fs';\nimport { resolve } from 'path';\nimport { writeThemeFiles } from './theme-generator.js';\nimport { copyStaticAssets, copyThemeResources } from './theme-copy.js';\n\n// matches theme name in './theme-my-theme.generated.js'\nconst nameRegex = /theme-(.*)\\.generated\\.js/;\n\nlet prevThemeName = undefined;\nlet firstThemeName = undefined;\n\n/**\n * Looks up for a theme resources in a current project and in jar dependencies,\n * copies the found resources and generates/updates meta data for webpack\n * compilation.\n *\n * @param {object} options application theme plugin mandatory options,\n * @see {@link ApplicationThemePlugin}\n *\n * @param logger application theme plugin logger\n */\nfunction processThemeResources(options, logger) {\n  const themeName = extractThemeName(options.frontendGeneratedFolder);\n  if (themeName) {\n    if (!prevThemeName && !firstThemeName) {\n      firstThemeName = themeName;\n    } else if (\n      (prevThemeName && prevThemeName !== themeName && firstThemeName !== themeName) ||\n      (!prevThemeName && firstThemeName !== themeName)\n    ) {\n      // Warning message is shown to the developer when:\n      // 1. He is switching to any theme, which is differ from one being set up\n      // on application startup, by changing theme name in `@Theme()`\n      // 2. He removes or comments out `@Theme()` to see how the app\n      // looks like without theming, and then again brings `@Theme()` back\n      // with a themeName which is differ from one being set up on application\n      // startup.\n      const warning = `Attention: Active theme is switched to '${themeName}'.`;\n      const description = `\n      Note that adding new style sheet files to '/themes/${themeName}/components', \n      may not be taken into effect until the next application restart.\n      Changes to already existing style sheet files are being reloaded as before.`;\n      logger.warn('*******************************************************************');\n      logger.warn(warning);\n      logger.warn(description);\n      logger.warn('*******************************************************************');\n    }\n    prevThemeName = themeName;\n\n    findThemeFolderAndHandleTheme(themeName, options, logger);\n  } else {\n    // This is needed in the situation that the user decides to comment or\n    // remove the @Theme(...) completely to see how the application looks\n    // without any theme. Then when the user brings back one of the themes,\n    // the previous theme should be undefined to enable us to detect the change.\n    prevThemeName = undefined;\n    logger.debug('Skipping Vaadin application theme handling.');\n    logger.trace('Most likely no @Theme annotation for application or only themeClass used.');\n  }\n}\n\n/**\n * Search for the given theme in the project and resource folders.\n *\n * @param {string} themeName name of theme to find\n * @param {object} options application theme plugin mandatory options,\n * @see {@link ApplicationThemePlugin}\n * @param logger application theme plugin logger\n * @return true or false for if theme was found\n */\nfunction findThemeFolderAndHandleTheme(themeName, options, logger) {\n  let themeFound = false;\n  for (let i = 0; i < options.themeProjectFolders.length; i++) {\n    const themeProjectFolder = options.themeProjectFolders[i];\n    if (existsSync(themeProjectFolder)) {\n      logger.debug(\"Searching themes folder '\" + themeProjectFolder + \"' for theme '\" + themeName + \"'\");\n      const handled = handleThemes(themeName, themeProjectFolder, options, logger);\n      if (handled) {\n        if (themeFound) {\n          throw new Error(\n            \"Found theme files in '\" +\n              themeProjectFolder +\n              \"' and '\" +\n              themeFound +\n              \"'. Theme should only be available in one folder\"\n          );\n        }\n        logger.debug(\"Found theme files from '\" + themeProjectFolder + \"'\");\n        themeFound = themeProjectFolder;\n      }\n    }\n  }\n\n  if (existsSync(options.themeResourceFolder)) {\n    if (themeFound && existsSync(resolve(options.themeResourceFolder, themeName))) {\n      throw new Error(\n        \"Theme '\" +\n          themeName +\n          \"'should not exist inside a jar and in the project at the same time\\n\" +\n          'Extending another theme is possible by adding { \"parent\": \"my-parent-theme\" } entry to the theme.json file inside your theme folder.'\n      );\n    }\n    logger.debug(\n      \"Searching theme jar resource folder '\" + options.themeResourceFolder + \"' for theme '\" + themeName + \"'\"\n    );\n    handleThemes(themeName, options.themeResourceFolder, options, logger);\n    themeFound = true;\n  }\n  return themeFound;\n}\n\n/**\n * Copies static resources for theme and generates/writes the\n * [theme-name].generated.js for webpack to handle.\n *\n * Note! If a parent theme is defined it will also be handled here so that the parent theme generated file is\n * generated in advance of the theme generated file.\n *\n * @param {string} themeName name of theme to handle\n * @param {string} themesFolder folder containing application theme folders\n * @param {object} options application theme plugin mandatory options,\n * @see {@link ApplicationThemePlugin}\n * @param {object} logger plugin logger instance\n *\n * @throws Error if parent theme defined, but can't locate parent theme\n *\n * @returns true if theme was found else false.\n */\nfunction handleThemes(themeName, themesFolder, options, logger) {\n  const themeFolder = resolve(themesFolder, themeName);\n  if (existsSync(themeFolder)) {\n    logger.debug('Found theme ', themeName, ' in folder ', themeFolder);\n\n    const themeProperties = getThemeProperties(themeFolder);\n\n    // If theme has parent handle parent theme immediately.\n    if (themeProperties.parent) {\n      const found = findThemeFolderAndHandleTheme(themeProperties.parent, options, logger);\n      if (!found) {\n        throw new Error(\n          \"Could not locate files for defined parent theme '\" +\n            themeProperties.parent +\n            \"'.\\n\" +\n            'Please verify that dependency is added or theme folder exists.'\n        );\n      }\n    }\n    copyStaticAssets(themeName, themeProperties, options.projectStaticAssetsOutputFolder, logger);\n    copyThemeResources(themeFolder, options.projectStaticAssetsOutputFolder, logger);\n\n    writeThemeFiles(themeFolder, themeName, themeProperties, options);\n    return true;\n  }\n  return false;\n}\n\nfunction getThemeProperties(themeFolder) {\n  const themePropertyFile = resolve(themeFolder, 'theme.json');\n  if (!existsSync(themePropertyFile)) {\n    return {};\n  }\n  const themePropertyFileAsString = readFileSync(themePropertyFile);\n  if (themePropertyFileAsString.length === 0) {\n    return {};\n  }\n  return JSON.parse(themePropertyFileAsString);\n}\n\n/**\n * Extracts current theme name from auto-generated 'theme.js' file located on a\n * given folder.\n * @param frontendGeneratedFolder folder in project containing 'theme.js' file\n * @returns {string} current theme name\n */\nfunction extractThemeName(frontendGeneratedFolder) {\n  if (!frontendGeneratedFolder) {\n    throw new Error(\n      \"Couldn't extract theme name from 'theme.js',\" +\n        ' because the path to folder containing this file is empty. Please set' +\n        ' the a correct folder path in ApplicationThemePlugin constructor' +\n        ' parameters.'\n    );\n  }\n  const generatedThemeFile = resolve(frontendGeneratedFolder, 'theme.js');\n  if (existsSync(generatedThemeFile)) {\n    // read theme name from the 'generated/theme.js' as there we always\n    // mark the used theme for webpack to handle.\n    const themeName = nameRegex.exec(readFileSync(generatedThemeFile, { encoding: 'utf8' }))[1];\n    if (!themeName) {\n      throw new Error(\"Couldn't parse theme name from '\" + generatedThemeFile + \"'.\");\n    }\n    return themeName;\n  } else {\n    return '';\n  }\n}\n\n/**\n * Finds all the parent themes located in the project themes folders and in\n * the JAR dependencies with respect to the given custom theme with\n * {@code themeName}.\n * @param {string} themeName given custom theme name to look parents for\n * @param {object} options application theme plugin mandatory options,\n * @see {@link ApplicationThemePlugin}\n * @returns {string[]} array of paths to found parent themes with respect to the\n * given custom theme\n */\nfunction findParentThemes(themeName, options) {\n  const existingThemeFolders = [options.themeResourceFolder, ...options.themeProjectFolders].filter((folder) =>\n    existsSync(folder)\n  );\n  return collectParentThemes(themeName, existingThemeFolders, false);\n}\n\nfunction collectParentThemes(themeName, themeFolders, isParent) {\n  let foundParentThemes = [];\n  themeFolders.forEach((folder) => {\n    const themeFolder = resolve(folder, themeName);\n    if (existsSync(themeFolder)) {\n      const themeProperties = getThemeProperties(themeFolder);\n\n      if (themeProperties.parent) {\n        foundParentThemes.push(...collectParentThemes(themeProperties.parent, themeFolders, true));\n        if (!foundParentThemes.length) {\n          throw new Error(\n            \"Could not locate files for defined parent theme '\" +\n              themeProperties.parent +\n              \"'.\\n\" +\n              'Please verify that dependency is added or theme folder exists.'\n          );\n        }\n      }\n      // Add a theme path to result collection only if a given themeName\n      // is supposed to be a parent theme\n      if (isParent) {\n        foundParentThemes.push(themeFolder);\n      }\n    }\n  });\n  return foundParentThemes;\n}\n\nexport { processThemeResources, extractThemeName, findParentThemes };\n", "const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\application-theme-plugin\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\application-theme-plugin\\\\theme-generator.js\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/plugins/application-theme-plugin/theme-generator.js\";/*\n * Copyright 2000-2023 Vaadin Ltd.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\n/**\n * This file handles the generation of the '[theme-name].js' to\n * the themes/[theme-name] folder according to properties from 'theme.json'.\n */\nimport { globSync } from 'glob';\nimport { resolve, basename } from 'path';\nimport { existsSync, readFileSync, writeFileSync } from 'fs';\nimport { checkModules } from './theme-copy.js';\n\n// Special folder inside a theme for component themes that go inside the component shadow root\nconst themeComponentsFolder = 'components';\n// The contents of a global CSS file with this name in a theme is always added to\n// the document. E.g. @font-face must be in this\nconst documentCssFilename = 'document.css';\n// styles.css is the only entrypoint css file with document.css. Everything else should be imported using css @import\nconst stylesCssFilename = 'styles.css';\n\nconst CSSIMPORT_COMMENT = 'CSSImport end';\nconst headerImport = `import 'construct-style-sheets-polyfill';\n`;\n\n/**\n * Generate the [themeName].js file for themeFolder which collects all required information from the folder.\n *\n * @param {string} themeFolder folder of the theme\n * @param {string} themeName name of the handled theme\n * @param {JSON} themeProperties content of theme.json\n * @param {Object} options build options (e.g. prod or dev mode)\n * @returns {string} theme file content\n */\nfunction writeThemeFiles(themeFolder, themeName, themeProperties, options) {\n  const productionMode = !options.devMode;\n  const useDevServerOrInProductionMode = !options.useDevBundle;\n  const outputFolder = options.frontendGeneratedFolder;\n  const styles = resolve(themeFolder, stylesCssFilename);\n  const documentCssFile = resolve(themeFolder, documentCssFilename);\n  const autoInjectComponents = themeProperties.autoInjectComponents ?? true;\n  const globalFilename = 'theme-' + themeName + '.global.generated.js';\n  const componentsFilename = 'theme-' + themeName + '.components.generated.js';\n  const themeFilename = 'theme-' + themeName + '.generated.js';\n\n  let themeFileContent = headerImport;\n  let globalImportContent = '// When this file is imported, global styles are automatically applied\\n';\n  let componentsFileContent = '';\n  var componentsFiles;\n\n  if (autoInjectComponents) {\n    componentsFiles = globSync('*.css', {\n      cwd: resolve(themeFolder, themeComponentsFolder),\n      nodir: true\n    });\n\n    if (componentsFiles.length > 0) {\n      componentsFileContent +=\n        \"import { unsafeCSS, registerStyles } from '@vaadin/vaadin-themable-mixin/register-styles';\\n\";\n    }\n  }\n\n  if (themeProperties.parent) {\n    themeFileContent += `import { applyTheme as applyBaseTheme } from './theme-${themeProperties.parent}.generated.js';\\n`;\n  }\n\n  themeFileContent += `import { injectGlobalCss } from 'Frontend/generated/jar-resources/theme-util.js';\\n`;\n  themeFileContent += `import './${componentsFilename}';\\n`;\n\n  themeFileContent += `let needsReloadOnChanges = false;\\n`;\n  const imports = [];\n  const componentCssImports = [];\n  const globalFileContent = [];\n  const globalCssCode = [];\n  const shadowOnlyCss = [];\n  const componentCssCode = [];\n  const parentTheme = themeProperties.parent ? 'applyBaseTheme(target);\\n' : '';\n  const parentThemeGlobalImport = themeProperties.parent\n    ? `import './theme-${themeProperties.parent}.global.generated.js';\\n`\n    : '';\n\n  const themeIdentifier = '_vaadintheme_' + themeName + '_';\n  const lumoCssFlag = '_vaadinthemelumoimports_';\n  const globalCssFlag = themeIdentifier + 'globalCss';\n  const componentCssFlag = themeIdentifier + 'componentCss';\n\n  if (!existsSync(styles)) {\n    if (productionMode) {\n      throw new Error(`styles.css file is missing and is needed for '${themeName}' in folder '${themeFolder}'`);\n    }\n    writeFileSync(\n      styles,\n      '/* Import your application global css files here or add the styles directly to this file */',\n      'utf8'\n    );\n  }\n\n  // styles.css will always be available as we write one if it doesn't exist.\n  let filename = basename(styles);\n  let variable = camelCase(filename);\n\n  /* LUMO */\n  const lumoImports = themeProperties.lumoImports || ['color', 'typography'];\n  if (lumoImports) {\n    lumoImports.forEach((lumoImport) => {\n      imports.push(`import { ${lumoImport} } from '@vaadin/vaadin-lumo-styles/${lumoImport}.js';\\n`);\n      if (lumoImport === 'utility' || lumoImport === 'badge' || lumoImport === 'typography' || lumoImport === 'color') {\n        // Inject into main document the same way as other Lumo styles are injected\n        imports.push(`import '@vaadin/vaadin-lumo-styles/${lumoImport}-global.js';\\n`);\n      }\n    });\n\n    lumoImports.forEach((lumoImport) => {\n      // Lumo is injected to the document by Lumo itself\n      shadowOnlyCss.push(`removers.push(injectGlobalCss(${lumoImport}.cssText, '', target, true));\\n`);\n    });\n  }\n\n  /* Theme */\n  if (useDevServerOrInProductionMode) {\n    globalFileContent.push(parentThemeGlobalImport);\n    globalFileContent.push(`import 'themes/${themeName}/${filename}';\\n`);\n\n    imports.push(`import ${variable} from 'themes/${themeName}/${filename}?inline';\\n`);\n    shadowOnlyCss.push(`removers.push(injectGlobalCss(${variable}.toString(), '', target));\\n    `);\n  }\n  if (existsSync(documentCssFile)) {\n    filename = basename(documentCssFile);\n    variable = camelCase(filename);\n\n    if (useDevServerOrInProductionMode) {\n      globalFileContent.push(`import 'themes/${themeName}/${filename}';\\n`);\n\n      imports.push(`import ${variable} from 'themes/${themeName}/${filename}?inline';\\n`);\n      shadowOnlyCss.push(`removers.push(injectGlobalCss(${variable}.toString(),'', document));\\n    `);\n    }\n  }\n\n  let i = 0;\n  if (themeProperties.documentCss) {\n    const missingModules = checkModules(themeProperties.documentCss);\n    if (missingModules.length > 0) {\n      throw Error(\n        \"Missing npm modules or files '\" +\n          missingModules.join(\"', '\") +\n          \"' for documentCss marked in 'theme.json'.\\n\" +\n          \"Install or update package(s) by adding a @NpmPackage annotation or install it using 'npm/pnpm/bun i'\"\n      );\n    }\n    themeProperties.documentCss.forEach((cssImport) => {\n      const variable = 'module' + i++;\n      imports.push(`import ${variable} from '${cssImport}?inline';\\n`);\n      // Due to chrome bug https://bugs.chromium.org/p/chromium/issues/detail?id=336876 font-face will not work\n      // inside shadowRoot so we need to inject it there also.\n      globalCssCode.push(`if(target !== document) {\n        removers.push(injectGlobalCss(${variable}.toString(), '', target));\n    }\\n    `);\n      globalCssCode.push(\n        `removers.push(injectGlobalCss(${variable}.toString(), '${CSSIMPORT_COMMENT}', document));\\n    `\n      );\n    });\n  }\n  if (themeProperties.importCss) {\n    const missingModules = checkModules(themeProperties.importCss);\n    if (missingModules.length > 0) {\n      throw Error(\n        \"Missing npm modules or files '\" +\n          missingModules.join(\"', '\") +\n          \"' for importCss marked in 'theme.json'.\\n\" +\n          \"Install or update package(s) by adding a @NpmPackage annotation or install it using 'npm/pnpm/bun i'\"\n      );\n    }\n    themeProperties.importCss.forEach((cssPath) => {\n      const variable = 'module' + i++;\n      globalFileContent.push(`import '${cssPath}';\\n`);\n      imports.push(`import ${variable} from '${cssPath}?inline';\\n`);\n      shadowOnlyCss.push(`removers.push(injectGlobalCss(${variable}.toString(), '${CSSIMPORT_COMMENT}', target));\\n`);\n    });\n  }\n\n  if (autoInjectComponents) {\n    componentsFiles.forEach((componentCss) => {\n      const filename = basename(componentCss);\n      const tag = filename.replace('.css', '');\n      const variable = camelCase(filename);\n      componentCssImports.push(\n        `import ${variable} from 'themes/${themeName}/${themeComponentsFolder}/${filename}?inline';\\n`\n      );\n      // Don't format as the generated file formatting will get wonky!\n      const componentString = `registerStyles(\n        '${tag}',\n        unsafeCSS(${variable}.toString())\n      );\n      `;\n      componentCssCode.push(componentString);\n    });\n  }\n\n  themeFileContent += imports.join('');\n\n  // Don't format as the generated file formatting will get wonky!\n  // If targets check that we only register the style parts once, checks exist for global css and component css\n  const themeFileApply = `\n  let themeRemovers = new WeakMap();\n  let targets = [];\n\n  export const applyTheme = (target) => {\n    const removers = [];\n    if (target !== document) {\n      ${shadowOnlyCss.join('')}\n    }\n    ${parentTheme}\n    ${globalCssCode.join('')}\n\n    if (import.meta.hot) {\n      targets.push(new WeakRef(target));\n      themeRemovers.set(target, removers);\n    }\n\n  }\n  \n`;\n  componentsFileContent += `\n${componentCssImports.join('')}\n\nif (!document['${componentCssFlag}']) {\n  ${componentCssCode.join('')}\n  document['${componentCssFlag}'] = true;\n}\n\nif (import.meta.hot) {\n  import.meta.hot.accept((module) => {\n    window.location.reload();\n  });\n}\n\n`;\n\n  themeFileContent += themeFileApply;\n  themeFileContent += `\nif (import.meta.hot) {\n  import.meta.hot.accept((module) => {\n\n    if (needsReloadOnChanges) {\n      window.location.reload();\n    } else {\n      targets.forEach(targetRef => {\n        const target = targetRef.deref();\n        if (target) {\n          themeRemovers.get(target).forEach(remover => remover())\n          module.applyTheme(target);\n        }\n      })\n    }\n  });\n\n  import.meta.hot.on('vite:afterUpdate', (update) => {\n    document.dispatchEvent(new CustomEvent('vaadin-theme-updated', { detail: update }));\n  });\n}\n\n`;\n\n  globalImportContent += `\n${globalFileContent.join('')}\n`;\n\n  writeIfChanged(resolve(outputFolder, globalFilename), globalImportContent);\n  writeIfChanged(resolve(outputFolder, themeFilename), themeFileContent);\n  writeIfChanged(resolve(outputFolder, componentsFilename), componentsFileContent);\n}\n\nfunction writeIfChanged(file, data) {\n  if (!existsSync(file) || readFileSync(file, { encoding: 'utf-8' }) !== data) {\n    writeFileSync(file, data);\n  }\n}\n\n/**\n * Make given string into camelCase.\n *\n * @param {string} str string to make into cameCase\n * @returns {string} camelCased version\n */\nfunction camelCase(str) {\n  return str\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, function (word, index) {\n      return index === 0 ? word.toLowerCase() : word.toUpperCase();\n    })\n    .replace(/\\s+/g, '')\n    .replace(/\\.|\\-/g, '');\n}\n\nexport { writeThemeFiles };\n", "const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\application-theme-plugin\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\application-theme-plugin\\\\theme-copy.js\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/plugins/application-theme-plugin/theme-copy.js\";/*\n * Copyright 2000-2023 Vaadin Ltd.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\n/**\n * This contains functions and features used to copy theme files.\n */\n\nimport { readdirSync, statSync, mkdirSync, existsSync, copyFileSync } from 'fs';\nimport { resolve, basename, relative, extname } from 'path';\nimport { globSync } from 'glob';\n\nconst ignoredFileExtensions = ['.css', '.js', '.json'];\n\n/**\n * Copy theme static resources to static assets folder. All files in the theme\n * folder will be copied excluding css, js and json files that will be\n * handled by webpack and not be shared as static files.\n *\n * @param {string} themeFolder Folder with theme file\n * @param {string} projectStaticAssetsOutputFolder resources output folder\n * @param {object} logger plugin logger\n */\nfunction copyThemeResources(themeFolder, projectStaticAssetsOutputFolder, logger) {\n  const staticAssetsThemeFolder = resolve(projectStaticAssetsOutputFolder, 'themes', basename(themeFolder));\n  const collection = collectFolders(themeFolder, logger);\n\n  // Only create assets folder if there are files to copy.\n  if (collection.files.length > 0) {\n    mkdirSync(staticAssetsThemeFolder, { recursive: true });\n    // create folders with\n    collection.directories.forEach((directory) => {\n      const relativeDirectory = relative(themeFolder, directory);\n      const targetDirectory = resolve(staticAssetsThemeFolder, relativeDirectory);\n\n      mkdirSync(targetDirectory, { recursive: true });\n    });\n\n    collection.files.forEach((file) => {\n      const relativeFile = relative(themeFolder, file);\n      const targetFile = resolve(staticAssetsThemeFolder, relativeFile);\n      copyFileIfAbsentOrNewer(file, targetFile, logger);\n    });\n  }\n}\n\n/**\n * Collect all folders with copyable files and all files to be copied.\n * Foled will not be added if no files in folder or subfolders.\n *\n * Files will not contain files with ignored extensions and folders only containing ignored files will not be added.\n *\n * @param folderToCopy folder we will copy files from\n * @param logger plugin logger\n * @return {{directories: [], files: []}} object containing directories to create and files to copy\n */\nfunction collectFolders(folderToCopy, logger) {\n  const collection = { directories: [], files: [] };\n  logger.trace('files in directory', readdirSync(folderToCopy));\n  readdirSync(folderToCopy).forEach((file) => {\n    const fileToCopy = resolve(folderToCopy, file);\n    try {\n      if (statSync(fileToCopy).isDirectory()) {\n        logger.debug('Going through directory', fileToCopy);\n        const result = collectFolders(fileToCopy, logger);\n        if (result.files.length > 0) {\n          collection.directories.push(fileToCopy);\n          logger.debug('Adding directory', fileToCopy);\n          collection.directories.push.apply(collection.directories, result.directories);\n          collection.files.push.apply(collection.files, result.files);\n        }\n      } else if (!ignoredFileExtensions.includes(extname(fileToCopy))) {\n        logger.debug('Adding file', fileToCopy);\n        collection.files.push(fileToCopy);\n      }\n    } catch (error) {\n      handleNoSuchFileError(fileToCopy, error, logger);\n    }\n  });\n  return collection;\n}\n\n/**\n * Copy any static node_modules assets marked in theme.json to\n * project static assets folder.\n *\n * The theme.json content for assets is set up as:\n * {\n *   assets: {\n *     \"node_module identifier\": {\n *       \"copy-rule\": \"target/folder\",\n *     }\n *   }\n * }\n *\n * This would mean that an asset would be built as:\n * \"@fortawesome/fontawesome-free\": {\n *   \"svgs/regular/**\": \"fortawesome/icons\"\n * }\n * Where '@fortawesome/fontawesome-free' is the npm package, 'svgs/regular/**' is what should be copied\n * and 'fortawesome/icons' is the target directory under projectStaticAssetsOutputFolder where things\n * will get copied to.\n *\n * Note! there can be multiple copy-rules with target folders for one npm package asset.\n *\n * @param {string} themeName name of the theme we are copying assets for\n * @param {json} themeProperties theme properties json with data on assets\n * @param {string} projectStaticAssetsOutputFolder project output folder where we copy assets to under theme/[themeName]\n * @param {object} logger plugin logger\n */\nfunction copyStaticAssets(themeName, themeProperties, projectStaticAssetsOutputFolder, logger) {\n  const assets = themeProperties['assets'];\n  if (!assets) {\n    logger.debug('no assets to handle no static assets were copied');\n    return;\n  }\n\n  mkdirSync(projectStaticAssetsOutputFolder, {\n    recursive: true\n  });\n  const missingModules = checkModules(Object.keys(assets));\n  if (missingModules.length > 0) {\n    throw Error(\n      \"Missing npm modules '\" +\n        missingModules.join(\"', '\") +\n        \"' for assets marked in 'theme.json'.\\n\" +\n        \"Install package(s) by adding a @NpmPackage annotation or install it using 'npm/pnpm/bun i'\"\n    );\n  }\n  Object.keys(assets).forEach((module) => {\n    const copyRules = assets[module];\n    Object.keys(copyRules).forEach((copyRule) => {\n      const nodeSources = resolve('node_modules/', module, copyRule);\n      const files = globSync(nodeSources, { nodir: true });\n      const targetFolder = resolve(projectStaticAssetsOutputFolder, 'themes', themeName, copyRules[copyRule]);\n\n      mkdirSync(targetFolder, {\n        recursive: true\n      });\n      files.forEach((file) => {\n        const copyTarget = resolve(targetFolder, basename(file));\n        copyFileIfAbsentOrNewer(file, copyTarget, logger);\n      });\n    });\n  });\n}\n\nfunction checkModules(modules) {\n  const missing = [];\n\n  modules.forEach((module) => {\n    if (!existsSync(resolve('node_modules/', module))) {\n      missing.push(module);\n    }\n  });\n\n  return missing;\n}\n\n/**\n * Copies given file to a given target path, if target file doesn't exist or if\n * file to copy is newer.\n * @param {string} fileToCopy path of the file to copy\n * @param {string} copyTarget path of the target file\n * @param {object} logger plugin logger\n */\nfunction copyFileIfAbsentOrNewer(fileToCopy, copyTarget, logger) {\n  try {\n    if (!existsSync(copyTarget) || statSync(copyTarget).mtime < statSync(fileToCopy).mtime) {\n      logger.trace('Copying: ', fileToCopy, '=>', copyTarget);\n      copyFileSync(fileToCopy, copyTarget);\n    }\n  } catch (error) {\n    handleNoSuchFileError(fileToCopy, error, logger);\n  }\n}\n\n// Ignores errors due to file missing during theme processing\n// This may happen for example when an IDE creates a temporary file\n// and then immediately deletes it\nfunction handleNoSuchFileError(file, error, logger) {\n  if (error.code === 'ENOENT') {\n    logger.warn('Ignoring not existing file ' + file + '. File may have been deleted during theme processing.');\n  } else {\n    throw error;\n  }\n}\n\nexport { checkModules, copyStaticAssets, copyThemeResources };\n", "const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\theme-loader\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\theme-loader\\\\theme-loader-utils.js\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/plugins/theme-loader/theme-loader-utils.js\";import { existsSync, readFileSync } from 'fs';\nimport { resolve, basename } from 'path';\nimport { globSync } from 'glob';\n\n// Collect groups [url(] ['|\"]optional './|../', file part and end of url\nconst urlMatcher = /(url\\(\\s*)(\\'|\\\")?(\\.\\/|\\.\\.\\/)(\\S*)(\\2\\s*\\))/g;\n\nfunction assetsContains(fileUrl, themeFolder, logger) {\n  const themeProperties = getThemeProperties(themeFolder);\n  if (!themeProperties) {\n    logger.debug('No theme properties found.');\n    return false;\n  }\n  const assets = themeProperties['assets'];\n  if (!assets) {\n    logger.debug('No defined assets in theme properties');\n    return false;\n  }\n  // Go through each asset module\n  for (let module of Object.keys(assets)) {\n    const copyRules = assets[module];\n    // Go through each copy rule\n    for (let copyRule of Object.keys(copyRules)) {\n      // if file starts with copyRule target check if file with path after copy target can be found\n      if (fileUrl.startsWith(copyRules[copyRule])) {\n        const targetFile = fileUrl.replace(copyRules[copyRule], '');\n        const files = globSync(resolve('node_modules/', module, copyRule), { nodir: true });\n\n        for (let file of files) {\n          if (file.endsWith(targetFile)) return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nfunction getThemeProperties(themeFolder) {\n  const themePropertyFile = resolve(themeFolder, 'theme.json');\n  if (!existsSync(themePropertyFile)) {\n    return {};\n  }\n  const themePropertyFileAsString = readFileSync(themePropertyFile);\n  if (themePropertyFileAsString.length === 0) {\n    return {};\n  }\n  return JSON.parse(themePropertyFileAsString);\n}\n\nfunction rewriteCssUrls(source, handledResourceFolder, themeFolder, logger, options) {\n  source = source.replace(urlMatcher, function (match, url, quoteMark, replace, fileUrl, endString) {\n    let absolutePath = resolve(handledResourceFolder, replace, fileUrl);\n    const existingThemeResource = absolutePath.startsWith(themeFolder) && existsSync(absolutePath);\n    if (existingThemeResource || assetsContains(fileUrl, themeFolder, logger)) {\n      // Adding ./ will skip css-loader, which should be done for asset files\n      // In a production build, the css file is in VAADIN/build and static files are in VAADIN/static, so ../static needs to be added\n      const replacement = options.devMode ? './' : '../static/';\n\n      const skipLoader = existingThemeResource ? '' : replacement;\n      const frontendThemeFolder = skipLoader + 'themes/' + basename(themeFolder);\n      logger.debug(\n        'Updating url for file',\n        \"'\" + replace + fileUrl + \"'\",\n        'to use',\n        \"'\" + frontendThemeFolder + '/' + fileUrl + \"'\"\n      );\n      const pathResolved = absolutePath.substring(themeFolder.length).replace(/\\\\/g, '/');\n\n      // keep the url the same except replace the ./ or ../ to themes/[themeFolder]\n      return url + (quoteMark ?? '') + frontendThemeFolder + pathResolved + endString;\n    } else if (options.devMode) {\n      logger.log(\"No rewrite for '\", match, \"' as the file was not found.\");\n    } else {\n      // In production, the css is in VAADIN/build but the theme files are in .\n      return url + (quoteMark ?? '') + '../../' + fileUrl + endString;\n    }\n    return match;\n  });\n  return source;\n}\n\nexport { rewriteCssUrls };\n", "{\n  \"frontendFolder\": \"C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/frontend\",\n  \"themeFolder\": \"themes\",\n  \"themeResourceFolder\": \"C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/frontend/generated/jar-resources\",\n  \"staticOutput\": \"C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/classes/META-INF/VAADIN/webapp/VAADIN/static\",\n  \"generatedFolder\": \"generated\",\n  \"statsOutput\": \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\classes\\\\META-INF\\\\VAADIN\\\\config\",\n  \"frontendBundleOutput\": \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\classes\\\\META-INF\\\\VAADIN\\\\webapp\",\n  \"devBundleOutput\": \"C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/dev-bundle/webapp\",\n  \"devBundleStatsOutput\": \"C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/dev-bundle/config\",\n  \"jarResourcesFolder\": \"C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/frontend/generated/jar-resources\",\n  \"themeName\": \"soportet.iv1.2\",\n  \"clientServiceWorkerSource\": \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\sw.ts\",\n  \"pwaEnabled\": true,\n  \"offlineEnabled\": true,\n  \"offlinePath\": \"'.'\"\n}", "const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\rollup-plugin-postcss-lit-custom\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\target\\\\plugins\\\\rollup-plugin-postcss-lit-custom\\\\rollup-plugin-postcss-lit.js\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/target/plugins/rollup-plugin-postcss-lit-custom/rollup-plugin-postcss-lit.js\";/**\n * MIT License\n\nCopyright (c) 2019 Umberto Pepato\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n */\n// This is https://github.com/umbopepato/rollup-plugin-postcss-lit 2.0.0 + https://github.com/umbopepato/rollup-plugin-postcss-lit/pull/54\n// to make it work with Vite 3\n// Once / if https://github.com/umbopepato/rollup-plugin-postcss-lit/pull/54 is merged this should be removed and rollup-plugin-postcss-lit should be used instead\n\nimport { createFilter } from '@rollup/pluginutils';\nimport transformAst from 'transform-ast';\n\nconst assetUrlRE = /__VITE_ASSET__([\\w$]+)__(?:\\$_(.*?)__)?/g\n\nconst escape = (str) =>\n  str\n    .replace(assetUrlRE, '${unsafeCSSTag(\"__VITE_ASSET__$1__$2\")}')\n    .replace(/`/g, '\\\\`')\n    .replace(/\\\\(?!`)/g, '\\\\\\\\');\n\nexport default function postcssLit(options = {}) {\n  const defaultOptions = {\n    include: '**/*.{css,sss,pcss,styl,stylus,sass,scss,less}',\n    exclude: null,\n    importPackage: 'lit'\n  };\n\n  const opts = { ...defaultOptions, ...options };\n  const filter = createFilter(opts.include, opts.exclude);\n\n  return {\n    name: 'postcss-lit',\n    enforce: 'post',\n    transform(code, id) {\n      if (!filter(id)) return;\n      const ast = this.parse(code, {});\n      // export default const css;\n      let defaultExportName;\n\n      // export default '...';\n      let isDeclarationLiteral = false;\n      const magicString = transformAst(code, { ast: ast }, (node) => {\n        if (node.type === 'ExportDefaultDeclaration') {\n          defaultExportName = node.declaration.name;\n\n          isDeclarationLiteral = node.declaration.type === 'Literal';\n        }\n      });\n\n      if (!defaultExportName && !isDeclarationLiteral) {\n        return;\n      }\n      magicString.walk((node) => {\n        if (defaultExportName && node.type === 'VariableDeclaration') {\n          const exportedVar = node.declarations.find((d) => d.id.name === defaultExportName);\n          if (exportedVar) {\n            exportedVar.init.edit.update(`cssTag\\`${escape(exportedVar.init.value)}\\``);\n          }\n        }\n\n        if (isDeclarationLiteral && node.type === 'ExportDefaultDeclaration') {\n          node.declaration.edit.update(`cssTag\\`${escape(node.declaration.value)}\\``);\n        }\n      });\n      magicString.prepend(`import {css as cssTag, unsafeCSS as unsafeCSSTag} from '${opts.importPackage}';\\n`);\n      return {\n        code: magicString.toString(),\n        map: magicString.generateMap({\n          hires: true\n        })\n      };\n    }\n  };\n};\n", "const __vite_injected_original_dirname = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\";const __vite_injected_original_filename = \"C:\\\\Users\\\\mramirezg\\\\Documents\\\\ideaProjects\\\\soporte-t-cnico-t-i-v1-22\\\\soporte-t-cnico-t-i-v1-2\\\\vite.config.ts\";const __vite_injected_original_import_meta_url = \"file:///C:/Users/mramirezg/Documents/ideaProjects/soporte-t-cnico-t-i-v1-22/soporte-t-cnico-t-i-v1-2/vite.config.ts\";import { UserConfigFn } from 'vite';\nimport { overrideVaadinConfig } from './vite.generated';\n\nconst customConfig: UserConfigFn = (env) => ({\n  // Here you can add custom Vite parameters\n  // https://vitejs.dev/config/\n});\n\nexport default overrideVaadinConfig(customConfig);\n"],
  "mappings": "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",
  "names": ["existsSync", "mkdirSync", "readdirSync", "readFileSync", "writeFileSync", "existsSync", "readFileSync", "resolve", "globSync", "resolve", "basename", "existsSync", "themeFolder", "themeFolder", "resolve", "globSync", "existsSync", "basename", "variable", "filename", "existsSync", "resolve", "themeFolder", "readFileSync", "existsSync", "readFileSync", "resolve", "basename", "globSync", "themeFolder", "getThemeProperties", "globSync", "resolve", "existsSync", "readFileSync", "replace", "basename", "require", "existsSync", "readFileSync", "mkdirSync", "bundle", "readdirSync", "themeFolder", "writeFileSync", "e", "path", "customConfig"]
}
