@wabot-dev/framework 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/src/_virtual/_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/src/_virtual/cjs.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
+import { __require as requireCjs } from '../node_modules/deepmerge/dist/cjs.js';
+
+var cjsExports = requireCjs();
+var merge = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
+
+export { merge as default };

package/dist/src/index.d.ts

@@ -775,6 +775,7 @@ declare class WhatsAppSenderByCloudApi extends WhatsAppSender {
 
 interface ICrudRepository<T> {
     find(id: string): Promise<T | null>;
+    findOrThrow(id: string): Promise<T>;
     findAll(id: string): Promise<T[]>;
     create(item: T): Promise<void>;
     update(item: T): Promise<void>;
@@ -825,6 +826,7 @@ declare class PgCrudRepository<P extends Persistent> extends PgRepositoryBase<P>
     protected readonly config: IPgRepositoryConfig<P>;
     constructor(pool: Pool, config: IPgRepositoryConfig<P>);
     find(id: string): Promise<P | null>;
+    findOrThrow(id: string): Promise<P>;
     findAll(): Promise<P[]>;
     create(item: P): Promise<void>;
     update(item: P): Promise<void>;
@@ -930,6 +932,14 @@ declare class RegisterUserModule {
     registerUserWithEmail(request: RegisterUserWithEmailRequest): Promise<string>;
 }
 
+interface IHtmlModuleOptions {
+    url: string;
+    title: string;
+}
+declare function HtmlModule(options: IHtmlModuleOptions): {
+    new (): {};
+};
+
 declare class PgUserRepository extends PgCrudRepository<User> implements IUserRepository {
     constructor(pool: Pool);
     findByConnection(query: IUserConnection): Promise<User | null>;
@@ -976,6 +986,12 @@ interface IGetConfig {
 
 declare function get(config?: IGetConfig): (target: object, propertyKey: string | symbol) => void;
 
+interface IPostConfig {
+    path?: string;
+}
+
+declare function post(config?: IPostConfig): (target: object, propertyKey: string | symbol) => void;
+
 interface IRestControllerConfig {
     path: string;
 }
@@ -1020,10 +1036,6 @@ declare function isNotEmpty(): (target: object, propertyKey: string | symbol) =>
 
 declare function isNumber(): (target: object, propertyKey: string | symbol) => void;
 
-declare const _IS_OPTIONAL_DUMMY_VALIDATOR_: (value: any) => {
-    value: any;
-    errors: never[];
-};
 declare function isOptional(): (target: object, propertyKey: string | symbol) => void;
 
 declare function isPresent(): (target: object, propertyKey: string | symbol) => void;
@@ -1109,4 +1121,4 @@ declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IM
 
 declare function validateModel2<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, EnvWhatsAppRepository, ExpressProvider, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IEmailService, type IEndPointMetadata, type IGetConfig, type IGetWhatsAppTemplateRequest, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type IReversibleMapper, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, _IS_OPTIONAL_DUMMY_VALIDATOR_, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isNotEmpty, isNumber, isOptional, isPresent, isString, max, min, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validable, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, validateModel2, whatsapp };
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IEmailService, type IEndPointMetadata, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type IReversibleMapper, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isNotEmpty, isNumber, isOptional, isPresent, isString, max, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validable, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, validateModel2, whatsapp };

package/dist/src/index.js

@@ -60,6 +60,7 @@ export { ValidateOneTimePasswordRequest } from './pre-made/module/authentication
 export { AuthenticationModule } from './pre-made/module/authentication/AuthenticationModule.js';
 export { RegisterUserWithEmailRequest } from './pre-made/module/register-user/requests/RegisterUserWithEmailRequest.js';
 export { RegisterUserModule } from './pre-made/module/register-user/RegisterUserModule.js';
+export { HtmlModule } from './pre-made/module/html/HtmlModule.js';
 export { EmailService } from './pre-made/service/EmailService.js';
 export { OtpService } from './pre-made/service/OtpService.js';
 export { PgUserRepository } from './pre-made/repository/user/pg/PgUserRepository.js';
@@ -73,6 +74,7 @@ export { PgRepositoryBase } from './repository/pg/PgRepositoryBase.js';
 export { Logger } from './logger/Logger.js';
 export { WabotEnv } from './env/WabotEnv.js';
 export { get } from './rest-controller/metadata/@get.js';
+export { post } from './rest-controller/metadata/@post.js';
 export { restController } from './rest-controller/metadata/@restController.js';
 export { RestControllerMetadataStore } from './rest-controller/metadata/RestControllerMetadataStore.js';
 export { runRestControllers } from './rest-controller/runRestControllers.js';
@@ -80,7 +82,7 @@ export { isBoolean } from './validation/metadata/@isBoolean.js';
 export { isDate } from './validation/metadata/@isDate.js';
 export { isNotEmpty } from './validation/metadata/@isNotEmpty.js';
 export { isNumber } from './validation/metadata/@isNumber.js';
-export { _IS_OPTIONAL_DUMMY_VALIDATOR_, isOptional } from './validation/metadata/@isOptional.js';
+export { isOptional } from './validation/metadata/@isOptional.js';
 export { isPresent } from './validation/metadata/@isPresent.js';
 export { isString } from './validation/metadata/@isString.js';
 export { max } from './validation/metadata/@max.js';

package/dist/src/node_modules/@selderee/plugin-htmlparser2/lib/hp2-builder.js

@@ -0,0 +1,90 @@
+import { Picker } from '../../../selderee/lib/selderee.js';
+import { isTag } from '../../../domhandler/lib/esm/node.js';
+
+function hp2Builder(nodes) {
+    return new Picker(handleArray(nodes));
+}
+function handleArray(nodes) {
+    const matchers = nodes.map(handleNode);
+    return (el, ...tail) => matchers.flatMap(m => m(el, ...tail));
+}
+function handleNode(node) {
+    switch (node.type) {
+        case 'terminal': {
+            const result = [node.valueContainer];
+            return (el, ...tail) => result;
+        }
+        case 'tagName':
+            return handleTagName(node);
+        case 'attrValue':
+            return handleAttrValueName(node);
+        case 'attrPresence':
+            return handleAttrPresenceName(node);
+        case 'pushElement':
+            return handlePushElementNode(node);
+        case 'popElement':
+            return handlePopElementNode(node);
+    }
+}
+function handleTagName(node) {
+    const variants = {};
+    for (const variant of node.variants) {
+        variants[variant.value] = handleArray(variant.cont);
+    }
+    return (el, ...tail) => {
+        const continuation = variants[el.name];
+        return (continuation) ? continuation(el, ...tail) : [];
+    };
+}
+function handleAttrPresenceName(node) {
+    const attrName = node.name;
+    const continuation = handleArray(node.cont);
+    return (el, ...tail) => (Object.prototype.hasOwnProperty.call(el.attribs, attrName))
+        ? continuation(el, ...tail)
+        : [];
+}
+function handleAttrValueName(node) {
+    const callbacks = [];
+    for (const matcher of node.matchers) {
+        const predicate = matcher.predicate;
+        const continuation = handleArray(matcher.cont);
+        callbacks.push((attr, el, ...tail) => (predicate(attr) ? continuation(el, ...tail) : []));
+    }
+    const attrName = node.name;
+    return (el, ...tail) => {
+        const attr = el.attribs[attrName];
+        return (attr || attr === '')
+            ? callbacks.flatMap(cb => cb(attr, el, ...tail))
+            : [];
+    };
+}
+function handlePushElementNode(node) {
+    const continuation = handleArray(node.cont);
+    const leftElementGetter = (node.combinator === '+')
+        ? getPrecedingElement
+        : getParentElement;
+    return (el, ...tail) => {
+        const next = leftElementGetter(el);
+        if (next === null) {
+            return [];
+        }
+        return continuation(next, el, ...tail);
+    };
+}
+const getPrecedingElement = (el) => {
+    const prev = el.prev;
+    if (prev === null) {
+        return null;
+    }
+    return (isTag(prev)) ? prev : getPrecedingElement(prev);
+};
+const getParentElement = (el) => {
+    const parent = el.parent;
+    return (parent && isTag(parent)) ? parent : null;
+};
+function handlePopElementNode(node) {
+    const continuation = handleArray(node.cont);
+    return (el, next, ...tail) => continuation(next, ...tail);
+}
+
+export { hp2Builder };

package/dist/src/node_modules/deepmerge/dist/cjs.js

@@ -0,0 +1,142 @@
+var cjs;
+var hasRequiredCjs;
+
+function requireCjs () {
+	if (hasRequiredCjs) return cjs;
+	hasRequiredCjs = 1;
+
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value)
+			&& !isSpecial(value)
+	};
+
+	function isNonNullObject(value) {
+		return !!value && typeof value === 'object'
+	}
+
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+
+		return stringValue === '[object RegExp]'
+			|| stringValue === '[object Date]'
+			|| isReactElement(value)
+	}
+
+	// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+	var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE
+	}
+
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {}
+	}
+
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return (options.clone !== false && options.isMergeableObject(value))
+			? deepmerge(emptyTarget(value), value, options)
+			: value
+	}
+
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options)
+		})
+	}
+
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) {
+			return deepmerge
+		}
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === 'function' ? customMerge : deepmerge
+	}
+
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols
+			? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+				return Object.propertyIsEnumerable.call(target, symbol)
+			})
+			: []
+	}
+
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+	}
+
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object
+		} catch(_) {
+			return false
+		}
+	}
+
+	// Protects from prototype poisoning and unexpected merging up the prototype chain.
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+			&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+				&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+	}
+
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) {
+			getKeys(target).forEach(function(key) {
+				destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+			});
+		}
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) {
+				return
+			}
+
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+				destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			} else {
+				destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+			}
+		});
+		return destination
+	}
+
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+		// implementations can use it. The caller may not replace it.
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+		var sourceIsArray = Array.isArray(source);
+		var targetIsArray = Array.isArray(target);
+		var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+		if (!sourceAndTargetTypesMatch) {
+			return cloneUnlessOtherwiseSpecified(source, options)
+		} else if (sourceIsArray) {
+			return options.arrayMerge(target, source, options)
+		} else {
+			return mergeObject(target, source, options)
+		}
+	}
+
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) {
+			throw new Error('first argument should be an array')
+		}
+
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options)
+		}, {})
+	};
+
+	var deepmerge_1 = deepmerge;
+
+	cjs = deepmerge_1;
+	return cjs;
+}
+
+export { requireCjs as __require };

package/dist/src/node_modules/dom-serializer/lib/esm/foreignNames.js

@@ -0,0 +1,102 @@
+const elementNames = new Map([
+    "altGlyph",
+    "altGlyphDef",
+    "altGlyphItem",
+    "animateColor",
+    "animateMotion",
+    "animateTransform",
+    "clipPath",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "foreignObject",
+    "glyphRef",
+    "linearGradient",
+    "radialGradient",
+    "textPath",
+].map((val) => [val.toLowerCase(), val]));
+const attributeNames = new Map([
+    "definitionURL",
+    "attributeName",
+    "attributeType",
+    "baseFrequency",
+    "baseProfile",
+    "calcMode",
+    "clipPathUnits",
+    "diffuseConstant",
+    "edgeMode",
+    "filterUnits",
+    "glyphRef",
+    "gradientTransform",
+    "gradientUnits",
+    "kernelMatrix",
+    "kernelUnitLength",
+    "keyPoints",
+    "keySplines",
+    "keyTimes",
+    "lengthAdjust",
+    "limitingConeAngle",
+    "markerHeight",
+    "markerUnits",
+    "markerWidth",
+    "maskContentUnits",
+    "maskUnits",
+    "numOctaves",
+    "pathLength",
+    "patternContentUnits",
+    "patternTransform",
+    "patternUnits",
+    "pointsAtX",
+    "pointsAtY",
+    "pointsAtZ",
+    "preserveAlpha",
+    "preserveAspectRatio",
+    "primitiveUnits",
+    "refX",
+    "refY",
+    "repeatCount",
+    "repeatDur",
+    "requiredExtensions",
+    "requiredFeatures",
+    "specularConstant",
+    "specularExponent",
+    "spreadMethod",
+    "startOffset",
+    "stdDeviation",
+    "stitchTiles",
+    "surfaceScale",
+    "systemLanguage",
+    "tableValues",
+    "targetX",
+    "targetY",
+    "textLength",
+    "viewBox",
+    "viewTarget",
+    "xChannelSelector",
+    "yChannelSelector",
+    "zoomAndPan",
+].map((val) => [val.toLowerCase(), val]));
+
+export { attributeNames, elementNames };

package/dist/src/node_modules/dom-serializer/lib/esm/index.js

@@ -0,0 +1,186 @@
+import { Text, Tag, Style, Script, CDATA, Comment, Directive, Doctype, Root } from '../../../domelementtype/lib/esm/index.js';
+import { elementNames, attributeNames } from './foreignNames.js';
+import { encodeXML, escapeText, escapeAttribute } from '../../../entities/lib/esm/escape.js';
+
+/*
+ * Module dependencies
+ */
+const unencodedElements = new Set([
+    "style",
+    "script",
+    "xmp",
+    "iframe",
+    "noembed",
+    "noframes",
+    "plaintext",
+    "noscript",
+]);
+function replaceQuotes(value) {
+    return value.replace(/"/g, """);
+}
+/**
+ * Format attributes
+ */
+function formatAttributes(attributes, opts) {
+    var _a;
+    if (!attributes)
+        return;
+    const encode = ((_a = opts.encodeEntities) !== null && _a !== void 0 ? _a : opts.decodeEntities) === false
+        ? replaceQuotes
+        : opts.xmlMode || opts.encodeEntities !== "utf8"
+            ? encodeXML
+            : escapeAttribute;
+    return Object.keys(attributes)
+        .map((key) => {
+        var _a, _b;
+        const value = (_a = attributes[key]) !== null && _a !== void 0 ? _a : "";
+        if (opts.xmlMode === "foreign") {
+            /* Fix up mixed-case attribute names */
+            key = (_b = attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;
+        }
+        if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
+            return key;
+        }
+        return `${key}="${encode(value)}"`;
+    })
+        .join(" ");
+}
+/**
+ * Self-enclosing tags
+ */
+const singleTag = new Set([
+    "area",
+    "base",
+    "basefont",
+    "br",
+    "col",
+    "command",
+    "embed",
+    "frame",
+    "hr",
+    "img",
+    "input",
+    "isindex",
+    "keygen",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+]);
+/**
+ * Renders a DOM node or an array of DOM nodes to a string.
+ *
+ * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
+ *
+ * @param node Node to be rendered.
+ * @param options Changes serialization behavior
+ */
+function render(node, options = {}) {
+    const nodes = "length" in node ? node : [node];
+    let output = "";
+    for (let i = 0; i < nodes.length; i++) {
+        output += renderNode(nodes[i], options);
+    }
+    return output;
+}
+function renderNode(node, options) {
+    switch (node.type) {
+        case Root:
+            return render(node.children, options);
+        // @ts-expect-error We don't use `Doctype` yet
+        case Doctype:
+        case Directive:
+            return renderDirective(node);
+        case Comment:
+            return renderComment(node);
+        case CDATA:
+            return renderCdata(node);
+        case Script:
+        case Style:
+        case Tag:
+            return renderTag(node, options);
+        case Text:
+            return renderText(node, options);
+    }
+}
+const foreignModeIntegrationPoints = new Set([
+    "mi",
+    "mo",
+    "mn",
+    "ms",
+    "mtext",
+    "annotation-xml",
+    "foreignObject",
+    "desc",
+    "title",
+]);
+const foreignElements = new Set(["svg", "math"]);
+function renderTag(elem, opts) {
+    var _a;
+    // Handle SVG / MathML in HTML
+    if (opts.xmlMode === "foreign") {
+        /* Fix up mixed-case element names */
+        elem.name = (_a = elementNames.get(elem.name)) !== null && _a !== void 0 ? _a : elem.name;
+        /* Exit foreign mode at integration points */
+        if (elem.parent &&
+            foreignModeIntegrationPoints.has(elem.parent.name)) {
+            opts = { ...opts, xmlMode: false };
+        }
+    }
+    if (!opts.xmlMode && foreignElements.has(elem.name)) {
+        opts = { ...opts, xmlMode: "foreign" };
+    }
+    let tag = `<${elem.name}`;
+    const attribs = formatAttributes(elem.attribs, opts);
+    if (attribs) {
+        tag += ` ${attribs}`;
+    }
+    if (elem.children.length === 0 &&
+        (opts.xmlMode
+            ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags
+                opts.selfClosingTags !== false
+            : // User explicitly asked for self-closing tags, even in HTML mode
+                opts.selfClosingTags && singleTag.has(elem.name))) {
+        if (!opts.xmlMode)
+            tag += " ";
+        tag += "/>";
+    }
+    else {
+        tag += ">";
+        if (elem.children.length > 0) {
+            tag += render(elem.children, opts);
+        }
+        if (opts.xmlMode || !singleTag.has(elem.name)) {
+            tag += `</${elem.name}>`;
+        }
+    }
+    return tag;
+}
+function renderDirective(elem) {
+    return `<${elem.data}>`;
+}
+function renderText(elem, opts) {
+    var _a;
+    let data = elem.data || "";
+    // If entities weren't decoded, no need to encode them back
+    if (((_a = opts.encodeEntities) !== null && _a !== void 0 ? _a : opts.decodeEntities) !== false &&
+        !(!opts.xmlMode &&
+            elem.parent &&
+            unencodedElements.has(elem.parent.name))) {
+        data =
+            opts.xmlMode || opts.encodeEntities !== "utf8"
+                ? encodeXML(data)
+                : escapeText(data);
+    }
+    return data;
+}
+function renderCdata(elem) {
+    return `<![CDATA[${elem.children[0].data}]]>`;
+}
+function renderComment(elem) {
+    return `<!--${elem.data}-->`;
+}
+
+export { render as default, render };

package/dist/src/node_modules/domelementtype/lib/esm/index.js

@@ -0,0 +1,53 @@
+/** Types of elements found in htmlparser2's DOM */
+var ElementType;
+(function (ElementType) {
+    /** Type for the root element of a document */
+    ElementType["Root"] = "root";
+    /** Type for Text */
+    ElementType["Text"] = "text";
+    /** Type for <? ... ?> */
+    ElementType["Directive"] = "directive";
+    /** Type for <!-- ... --> */
+    ElementType["Comment"] = "comment";
+    /** Type for <script> tags */
+    ElementType["Script"] = "script";
+    /** Type for <style> tags */
+    ElementType["Style"] = "style";
+    /** Type for Any tag */
+    ElementType["Tag"] = "tag";
+    /** Type for <![CDATA[ ... ]]> */
+    ElementType["CDATA"] = "cdata";
+    /** Type for <!doctype ...> */
+    ElementType["Doctype"] = "doctype";
+})(ElementType || (ElementType = {}));
+/**
+ * Tests whether an element is a tag or not.
+ *
+ * @param elem Element to test
+ */
+function isTag(elem) {
+    return (elem.type === ElementType.Tag ||
+        elem.type === ElementType.Script ||
+        elem.type === ElementType.Style);
+}
+// Exports for backwards compatibility
+/** Type for the root element of a document */
+const Root = ElementType.Root;
+/** Type for Text */
+const Text = ElementType.Text;
+/** Type for <? ... ?> */
+const Directive = ElementType.Directive;
+/** Type for <!-- ... --> */
+const Comment = ElementType.Comment;
+/** Type for <script> tags */
+const Script = ElementType.Script;
+/** Type for <style> tags */
+const Style = ElementType.Style;
+/** Type for Any tag */
+const Tag = ElementType.Tag;
+/** Type for <![CDATA[ ... ]]> */
+const CDATA = ElementType.CDATA;
+/** Type for <!doctype ...> */
+const Doctype = ElementType.Doctype;
+
+export { CDATA, Comment, Directive, Doctype, ElementType, Root, Script, Style, Tag, Text, isTag };