keycloakify 10.1.3 → 11.0.0

package/bin/499.index.js

@@ -19,12 +19,13 @@ exports.modules = {
 /* harmony import */ var _babel_generator__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(92332);
 /* harmony import */ var _babel_types__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(7912);
 /* harmony import */ var _babel_types__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_babel_types__WEBPACK_IMPORTED_MODULE_7__);
-/* harmony import */ var _tools_escapeStringForPropertiesFile__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(27190);
+/* harmony import */ var _tools_escapeStringForPropertiesFile__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(27190);
 /* harmony import */ var _tools_getThisCodebaseRootDirPath__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(58822);
 /* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(57147);
 /* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_9__);
 /* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(88078);
 /* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_10__);
+/* harmony import */ var _tools_getAbsoluteAndInOsFormatPath__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(84794);
 
 
 
@@ -37,19 +38,19 @@ exports.modules = {
 
 
 
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_10__.assert)();
 function generateMessageProperties(params) {
-    const { themeSrcDirPath, themeType } = params;
+    const { buildContext, themeType } = params;
     const baseMessagesDirPath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)((0,_tools_getThisCodebaseRootDirPath__WEBPACK_IMPORTED_MODULE_8__/* .getThisCodebaseRootDirPath */ .e)(), "src", themeType, "i18n", "messages_defaultSet");
-    const baseMessageBundle = Object.fromEntries(fs__WEBPACK_IMPORTED_MODULE_9__.readdirSync(baseMessagesDirPath)
-        .filter(baseName => baseName !== "index.ts")
+    const messages_defaultSet_by_languageTag_defaultSet = Object.fromEntries(fs__WEBPACK_IMPORTED_MODULE_9__.readdirSync(baseMessagesDirPath)
+        .filter(basename => basename !== "index.ts" && basename !== "types.ts")
         .map(basename => ({
         languageTag: basename.replace(/\.ts$/, ""),
         filePath: (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(baseMessagesDirPath, basename)
     }))
         .map(({ languageTag, filePath }) => {
-        const lines = fs__WEBPACK_IMPORTED_MODULE_9__.readFileSync(filePath)
-            .toString("utf8")
-            .split(/\r?\n/);
+        const lines = fs__WEBPACK_IMPORTED_MODULE_9__.readFileSync(filePath).toString("utf8").split(/\r?\n/);
         let messagesJson = "{";
         let isInDeclaration = false;
         for (const line of lines) {
@@ -70,7 +71,7 @@ function generateMessageProperties(params) {
     }));
     const { i18nTsFilePath } = (() => {
         let files = (0,_tools_crawl__WEBPACK_IMPORTED_MODULE_1__/* .crawl */ .J)({
-            dirPath: (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(themeSrcDirPath, themeType),
+            dirPath: (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(buildContext.themeSrcDirPath, themeType),
             returnedPathsType: "absolute"
         });
         files = files.filter(file => {
@@ -84,72 +85,231 @@ function generateMessageProperties(params) {
             return aIsI18nFile === bIsI18nFile ? 0 : aIsI18nFile ? -1 : 1;
         });
         files = files.sort((a, b) => a.length - b.length);
-        files = files.filter(file => fs__WEBPACK_IMPORTED_MODULE_9__.readFileSync(file).toString("utf8").includes("createUseI18n("));
+        files = files.filter(file => fs__WEBPACK_IMPORTED_MODULE_9__.readFileSync(file).toString("utf8").includes("i18nBuilder"));
         const i18nTsFilePath = files[0];
         return { i18nTsFilePath };
     })();
-    const messageBundle = (() => {
+    const i18nTsRoot = (() => {
         if (i18nTsFilePath === undefined) {
             return undefined;
         }
-        const root = recast__WEBPACK_IMPORTED_MODULE_4__/* .parse */ .Qc(fs__WEBPACK_IMPORTED_MODULE_9__.readFileSync(i18nTsFilePath).toString("utf8"), {
-            parser: {
-                parse: (code) => _babel_parser__WEBPACK_IMPORTED_MODULE_5__/* .parse */ .Qc(code, {
-                    sourceType: "module",
-                    plugins: ["typescript"]
-                }),
-                generator: _babel_generator__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .ZP,
-                types: _babel_types__WEBPACK_IMPORTED_MODULE_7__
+        const root = recastParseTs(i18nTsFilePath);
+        return root;
+    })();
+    const messages_defaultSet_by_languageTag_notInDefaultSet = (() => {
+        if (i18nTsRoot === undefined) {
+            return undefined;
+        }
+        let extraLanguageEntryByLanguageTag = {};
+        recast__WEBPACK_IMPORTED_MODULE_4__/* .visit */ .Vn(i18nTsRoot, {
+            visitCallExpression: function (path) {
+                const node = path.node;
+                // Check if the callee is a MemberExpression with property 'withExtraLanguages'
+                if (node.callee.type === "MemberExpression" &&
+                    node.callee.property.type === "Identifier" &&
+                    node.callee.property.name === "withExtraLanguages") {
+                    const arg = node.arguments[0];
+                    if (arg && arg.type === "ObjectExpression") {
+                        // Iterate over the properties of the object
+                        arg.properties.forEach(prop => {
+                            if (prop.type === "ObjectProperty" &&
+                                prop.key.type === "Identifier") {
+                                const lang = prop.key.name;
+                                const value = prop.value;
+                                if (value.type === "ObjectExpression") {
+                                    let label = undefined;
+                                    let pathStr = undefined;
+                                    // Iterate over the properties of the language object
+                                    value.properties.forEach(p => {
+                                        if (p.type === "ObjectProperty" &&
+                                            p.key.type === "Identifier") {
+                                            if (p.key.name === "label" &&
+                                                p.value.type === "StringLiteral") {
+                                                label = p.value.value;
+                                            }
+                                            if (p.key.name === "getMessages" &&
+                                                (p.value.type ===
+                                                    "ArrowFunctionExpression" ||
+                                                    p.value.type === "FunctionExpression")) {
+                                                // Extract the import path from the function body
+                                                const body = p.value.body;
+                                                if (body.type === "CallExpression" &&
+                                                    body.callee.type === "Import") {
+                                                    const importArg = body.arguments[0];
+                                                    if (importArg.type === "StringLiteral") {
+                                                        pathStr = importArg.value;
+                                                    }
+                                                }
+                                                else if (body.type === "BlockStatement") {
+                                                    // If the function body is a block (e.g., function with braces {})
+                                                    // Look for return statement
+                                                    body.body.forEach(statement => {
+                                                        if (statement.type ===
+                                                            "ReturnStatement" &&
+                                                            statement.argument &&
+                                                            statement.argument.type ===
+                                                                "CallExpression" &&
+                                                            statement.argument.callee
+                                                                .type === "Import") {
+                                                            const importArg = statement.argument
+                                                                .arguments[0];
+                                                            if (importArg.type ===
+                                                                "StringLiteral") {
+                                                                pathStr = importArg.value;
+                                                            }
+                                                        }
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    });
+                                    if (label && pathStr) {
+                                        extraLanguageEntryByLanguageTag[lang] = {
+                                            label,
+                                            path: pathStr
+                                        };
+                                    }
+                                }
+                            }
+                        });
+                    }
+                    return false; // Stop traversing this path
+                }
+                this.traverse(path); // Continue traversing other paths
             }
         });
-        let messageBundleDeclarationTsCode = undefined;
-        recast__WEBPACK_IMPORTED_MODULE_4__/* .visit */ .Vn(root, {
+        const messages_defaultSet_by_languageTag_notInDefaultSet = Object.fromEntries(Object.entries(extraLanguageEntryByLanguageTag).map(([languageTag, { path: relativePathWithoutExt }]) => [
+            languageTag,
+            (() => {
+                const filePath = (0,_tools_getAbsoluteAndInOsFormatPath__WEBPACK_IMPORTED_MODULE_11__/* .getAbsoluteAndInOsFormatPath */ .c)({
+                    pathIsh: relativePathWithoutExt.endsWith(".ts")
+                        ? relativePathWithoutExt
+                        : `${relativePathWithoutExt}.ts`,
+                    cwd: (0,path__WEBPACK_IMPORTED_MODULE_2__.dirname)(i18nTsFilePath)
+                });
+                const root = recastParseTs(filePath);
+                let declarationCode = "";
+                recast__WEBPACK_IMPORTED_MODULE_4__/* .visit */ .Vn(root, {
+                    visitVariableDeclarator: function (path) {
+                        const node = path.node;
+                        // Check if the variable name is 'messages'
+                        if (node.id.type === "Identifier" &&
+                            node.id.name === "messages") {
+                            // Ensure there is an initializer
+                            if (node.init) {
+                                // Generate code from the initializer, preserving comments
+                                declarationCode = recast__WEBPACK_IMPORTED_MODULE_4__/* .print */ .S0(node.init)
+                                    .code.replace(/}.*$/, "}");
+                            }
+                            return false; // Stop traversing this path
+                        }
+                        this.traverse(path); // Continue traversing other paths
+                    }
+                });
+                (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_10__.assert)(declarationCode !== undefined, `${filePath} does not contain a 'messages' variable declaration`);
+                let messages = {};
+                try {
+                    eval(`${(0,tsafe_symToStr__WEBPACK_IMPORTED_MODULE_3__/* .symToStr */ .r)({ messages })} = ${declarationCode};`);
+                }
+                catch (_a) {
+                    throw new Error(`The declaration of 'message' in ${filePath} cannot be statically evaluated: ${declarationCode}`);
+                }
+                return messages;
+            })()
+        ]));
+        return messages_defaultSet_by_languageTag_notInDefaultSet;
+    })();
+    const messages_defaultSet_by_languageTag = Object.assign(Object.assign({}, messages_defaultSet_by_languageTag_defaultSet), messages_defaultSet_by_languageTag_notInDefaultSet);
+    const messages_themeDefined_by_languageTag = (() => {
+        if (i18nTsRoot === undefined) {
+            return undefined;
+        }
+        let firstArgumentCode = undefined;
+        recast__WEBPACK_IMPORTED_MODULE_4__/* .visit */ .Vn(i18nTsRoot, {
             visitCallExpression: function (path) {
-                if (path.node.callee.type === "Identifier" &&
-                    path.node.callee.name === "createUseI18n") {
-                    messageBundleDeclarationTsCode = (0,_babel_generator__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .ZP)(path.node.arguments[0]).code;
+                const node = path.node;
+                if (node.callee.type === "MemberExpression" &&
+                    node.callee.property.type === "Identifier" &&
+                    node.callee.property.name === "withCustomTranslations") {
+                    firstArgumentCode = (0,_babel_generator__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .ZP)(node.arguments[0]).code;
                     return false;
                 }
                 this.traverse(path);
             }
         });
-        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_10__.assert)(messageBundleDeclarationTsCode !== undefined);
-        let messageBundle = {};
+        if (firstArgumentCode === undefined) {
+            return undefined;
+        }
+        let messages_themeDefined_by_languageTag = {};
         try {
-            eval(`${(0,tsafe_symToStr__WEBPACK_IMPORTED_MODULE_3__/* .symToStr */ .r)({ messageBundle })} = ${messageBundleDeclarationTsCode}`);
+            eval(`${(0,tsafe_symToStr__WEBPACK_IMPORTED_MODULE_3__/* .symToStr */ .r)({ messages_themeDefined_by_languageTag })} = ${firstArgumentCode}`);
         }
         catch (_a) {
             console.warn([
-                "WARNING: Make sure the messageBundle your provided as argument of createUseI18n can be statically evaluated.",
-                "This is important because we need to put your i18n messages in messages_*.properties files",
-                "or they won't be available server side.",
-                "\n",
-                "The following code could not be evaluated:",
-                "\n",
-                messageBundleDeclarationTsCode
+                "WARNING: The argument of withCustomTranslations can't be statically evaluated!",
+                "This needs to be fixed refer to the documentation: https://docs.keycloakify.dev/i18n",
+                firstArgumentCode
             ].join(" "));
+            return undefined;
         }
-        return messageBundle;
+        return messages_themeDefined_by_languageTag;
     })();
-    const mergedMessageBundle = Object.fromEntries(Object.entries(baseMessageBundle).map(([languageTag, messages]) => {
-        var _a, _b, _c;
-        return [
-            languageTag,
-            Object.assign(Object.assign({}, messages), (messageBundle === undefined
-                ? {}
-                : (_c = (_b = (_a = messageBundle[languageTag]) !== null && _a !== void 0 ? _a : messageBundle[_shared_constants__WEBPACK_IMPORTED_MODULE_0__/* .FALLBACK_LANGUAGE_TAG */ ._L]) !== null && _b !== void 0 ? _b : messageBundle[Object.keys(messageBundle)[0]]) !== null && _c !== void 0 ? _c : {}))
-        ];
-    }));
-    const messageProperties = Object.entries(mergedMessageBundle).map(([languageTag, messages]) => ({
-        languageTag,
-        propertiesFileSource: [
-            "",
-            ...(themeType !== "account" ? ["parent=base"] : []),
-            ...Object.entries(messages).map(([key, value]) => `${key}=${(0,_tools_escapeStringForPropertiesFile__WEBPACK_IMPORTED_MODULE_11__/* .escapeStringForPropertiesFile */ .y)(value)}`),
-            ""
-        ].join("\n")
-    }));
-    return messageProperties;
+    const languageTags = Object.keys(messages_defaultSet_by_languageTag);
+    return {
+        languageTags,
+        writeMessagePropertiesFiles: ({ messageDirPath, themeName }) => {
+            for (const languageTag of languageTags) {
+                const messages = Object.assign({}, messages_defaultSet_by_languageTag[languageTag]);
+                add_theme_defined_messages: {
+                    if (messages_themeDefined_by_languageTag === undefined) {
+                        break add_theme_defined_messages;
+                    }
+                    let messages_themeDefined = messages_themeDefined_by_languageTag[languageTag];
+                    if (messages_themeDefined === undefined) {
+                        messages_themeDefined =
+                            messages_themeDefined_by_languageTag[_shared_constants__WEBPACK_IMPORTED_MODULE_0__/* .FALLBACK_LANGUAGE_TAG */ ._L];
+                    }
+                    if (messages_themeDefined === undefined) {
+                        messages_themeDefined =
+                            messages_themeDefined_by_languageTag[Object.keys(messages_themeDefined_by_languageTag)[0]];
+                    }
+                    if (messages_themeDefined === undefined) {
+                        break add_theme_defined_messages;
+                    }
+                    for (const [key, messageOrMessageByThemeName] of Object.entries(messages_themeDefined)) {
+                        const message = (() => {
+                            if (typeof messageOrMessageByThemeName === "string") {
+                                return messageOrMessageByThemeName;
+                            }
+                            const message = messageOrMessageByThemeName[themeName];
+                            (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_10__.assert)(message !== undefined);
+                            return message;
+                        })();
+                        messages[key] = message;
+                    }
+                }
+                const propertiesFileSource = [
+                    "",
+                    ...Object.entries(messages).map(([key, value]) => `${key}=${(0,_tools_escapeStringForPropertiesFile__WEBPACK_IMPORTED_MODULE_12__/* .escapeStringForPropertiesFile */ .y)(value)}`),
+                    ""
+                ].join("\n");
+                fs__WEBPACK_IMPORTED_MODULE_9__.mkdirSync(messageDirPath, { recursive: true });
+                fs__WEBPACK_IMPORTED_MODULE_9__.writeFileSync((0,path__WEBPACK_IMPORTED_MODULE_2__.join)(messageDirPath, `messages_${languageTag}.properties`), Buffer.from(propertiesFileSource, "utf8"));
+            }
+        }
+    };
+}
+function recastParseTs(filePath) {
+    return recast__WEBPACK_IMPORTED_MODULE_4__/* .parse */ .Qc(fs__WEBPACK_IMPORTED_MODULE_9__.readFileSync(filePath).toString("utf8"), {
+        parser: {
+            parse: (code) => _babel_parser__WEBPACK_IMPORTED_MODULE_5__/* .parse */ .Qc(code, {
+                sourceType: "module",
+                plugins: ["typescript"]
+            }),
+            generator: _babel_generator__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .ZP,
+            types: _babel_types__WEBPACK_IMPORTED_MODULE_7__
+        }
+    });
 }
 //# sourceMappingURL=generateMessageProperties.js.map
 
@@ -652,6 +812,7 @@ async function generateResourcesForMainTheme(params) {
         const { themeType } = params;
         return (0,external_path_.join)(resourcesDirPath, "theme", themeName, themeType);
     };
+    const writeMessagePropertiesFilesByThemeType = {};
     for (const themeType of ["login", "account"]) {
         if (!buildContext.implementedThemeTypes[themeType].isImplemented) {
             continue;
@@ -746,20 +907,22 @@ async function generateResourcesForMainTheme(params) {
             const { ftlCode } = generateFtlFilesCode({ pageId });
             external_fs_.writeFileSync((0,external_path_.join)(themeTypeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
         });
+        let languageTags = undefined;
         i18n_messages_generation: {
             if (isForAccountSpa) {
                 break i18n_messages_generation;
             }
-            (0,generateMessageProperties/* generateMessageProperties */.k)({
-                themeSrcDirPath: buildContext.themeSrcDirPath,
+            const wrap = (0,generateMessageProperties/* generateMessageProperties */.k)({
+                buildContext,
                 themeType
-            }).forEach(({ languageTag, propertiesFileSource }) => {
-                const messagesDirPath = (0,external_path_.join)(themeTypeDirPath, "messages");
-                external_fs_.mkdirSync((0,external_path_.join)(themeTypeDirPath, "messages"), {
-                    recursive: true
-                });
-                const propertiesFilePath = (0,external_path_.join)(messagesDirPath, `messages_${languageTag}.properties`);
-                external_fs_.writeFileSync(propertiesFilePath, Buffer.from(propertiesFileSource, "utf8"));
+            });
+            languageTags = wrap.languageTags;
+            const { writeMessagePropertiesFiles } = wrap;
+            writeMessagePropertiesFilesByThemeType[themeType] =
+                writeMessagePropertiesFiles;
+            writeMessagePropertiesFiles({
+                messageDirPath: (0,external_path_.join)(themeTypeDirPath, "messages"),
+                themeName
             });
         }
         bring_in_account_v3_i18n_messages: {
@@ -804,7 +967,10 @@ async function generateResourcesForMainTheme(params) {
             })()}`,
             ...(isForAccountSpa ? ["deprecatedMode=false"] : []),
             ...((_a = buildContext.extraThemeProperties) !== null && _a !== void 0 ? _a : []),
-            ...buildContext.environmentVariables.map(({ name, default: defaultValue }) => `${name}=\${env.${name}:${(0,escapeStringForPropertiesFile/* escapeStringForPropertiesFile */.y)(defaultValue)}}`)
+            ...buildContext.environmentVariables.map(({ name, default: defaultValue }) => `${name}=\${env.${name}:${(0,escapeStringForPropertiesFile/* escapeStringForPropertiesFile */.y)(defaultValue)}}`),
+            ...(languageTags === undefined
+                ? []
+                : [`locales=${languageTags.join(",")}`])
         ].join("\n\n"), "utf8"));
     }
     email: {
@@ -848,6 +1014,19 @@ async function generateResourcesForMainTheme(params) {
             getNewMetaInfKeycloakTheme: () => metaInfKeycloakThemes
         });
     }
+    return {
+        writeMessagePropertiesFilesForThemeVariant: ({ getMessageDirPath, themeName }) => {
+            (0,objectEntries.objectEntries)(writeMessagePropertiesFilesByThemeType).forEach(([themeType, writeMessagePropertiesFiles]) => {
+                if (writeMessagePropertiesFiles === undefined) {
+                    return;
+                }
+                writeMessagePropertiesFiles({
+                    messageDirPath: getMessageDirPath({ themeType }),
+                    themeName
+                });
+            });
+        }
+    };
 }
 //# sourceMappingURL=generateResourcesForMainTheme.js.map
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateResources/generateResourcesForThemeVariant.js
@@ -855,13 +1034,13 @@ async function generateResourcesForMainTheme(params) {
 
 
 
-(0,assert.assert)();
 function generateResourcesForThemeVariant(params) {
-    const { resourcesDirPath, themeName, themeVariantName } = params;
+    const { resourcesDirPath, themeName, themeVariantName, writeMessagePropertiesFiles } = params;
     const mainThemeDirPath = (0,external_path_.join)(resourcesDirPath, "theme", themeName);
+    const themeVariantDirPath = (0,external_path_.join)(mainThemeDirPath, "..", themeVariantName);
     (0,transformCodebase/* transformCodebase */.N)({
         srcDirPath: mainThemeDirPath,
-        destDirPath: (0,external_path_.join)(mainThemeDirPath, "..", themeVariantName),
+        destDirPath: themeVariantDirPath,
         transformSourceCode: ({ fileRelativePath, sourceCode }) => {
             if ((0,external_path_.extname)(fileRelativePath) === ".ftl" &&
                 fileRelativePath.split(external_path_.sep).length === 2) {
@@ -890,6 +1069,10 @@ function generateResourcesForThemeVariant(params) {
             return newMetaInfKeycloakTheme;
         }
     });
+    writeMessagePropertiesFiles({
+        getMessageDirPath: ({ themeType }) => (0,external_path_.join)(themeVariantDirPath, themeType, "messages"),
+        themeName: themeVariantName
+    });
 }
 //# sourceMappingURL=generateResourcesForThemeVariant.js.map
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateResources/generateResources.js
@@ -905,7 +1088,7 @@ async function generateResources(params) {
     if (external_fs_default().existsSync(resourcesDirPath)) {
         (0,fs_rmSync/* rmSync */.a)(resourcesDirPath, { recursive: true });
     }
-    await generateResourcesForMainTheme({
+    const { writeMessagePropertiesFilesForThemeVariant } = await generateResourcesForMainTheme({
         resourcesDirPath,
         themeName,
         buildContext
@@ -914,7 +1097,8 @@ async function generateResources(params) {
         generateResourcesForThemeVariant({
             resourcesDirPath,
             themeName,
-            themeVariantName
+            themeVariantName,
+            writeMessagePropertiesFiles: writeMessagePropertiesFilesForThemeVariant
         });
     }
 }

package/bin/main.js

@@ -8785,7 +8785,7 @@ var eventemitter3 = __nccwpck_require__(11848);
 // EXTERNAL MODULE: external "tty"
 var external_tty_ = __nccwpck_require__(76224);
 var external_tty_namespaceObject = /*#__PURE__*/__nccwpck_require__.t(external_tty_, 2);
-;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/colorette/index.js
+;// CONCATENATED MODULE: ./node_modules/colorette/index.js
 
 
 const {

package/lib/kcSanitize/HtmlPolicyBuilder.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="dompurify" />
+import { DOMPurify } from "../../tools/vendor/dompurify";
+export declare class HtmlPolicyBuilder {
+    private globalAttributesAllowed;
+    private tagsAllowed;
+    private tagsAllowedWithNoAttribute;
+    private currentAttribute;
+    private isStylingAllowed;
+    private allowedProtocols;
+    private enforceRelNofollow;
+    private DOMPurify;
+    constructor(dependencyInjections: Partial<{
+        DOMPurify: typeof DOMPurify;
+    }>);
+    allowWithoutAttributes(tag: string): this;
+    allowAttributes(...args: string[]): this;
+    matching(matchingPattern: RegExp | ((value: string) => boolean)): this;
+    globally(): this;
+    allowStyling(): this;
+    onElements(...tags: string[]): this;
+    allowElements(...tags: string[]): this;
+    requireRelNofollowOnLinks(): this;
+    allowStandardUrlProtocols(): this;
+    apply(html: string): string;
+    private setupHooks;
+    private getAllowedAttributes;
+    private getAllowedUriRegexp;
+}