html-minifier 3.5.21 → 5.0.0

package/dist/types/lib/attributes.d.ts

@@ -0,0 +1,87 @@
+/**
+ * HTML attribute parsing, decoding, and minification
+ */
+import type { ProcessedOptions } from './options.js';
+export type HTMLAttribute = {
+    name: string;
+    value?: string | undefined;
+    quote?: string;
+    customAssign?: string;
+    customOpen?: string;
+    customClose?: string;
+};
+/**
+ * @param {string} text
+ * @param {ProcessedOptions} options
+ */
+declare function isIgnoredComment(text: string, options: ProcessedOptions): boolean;
+/**
+ * Remove duplicate attributes from an attribute list.
+ * Per HTML spec, when an attribute appears multiple times, the first occurrence wins.
+ * Duplicate attributes result in invalid HTML, so only the first is kept.
+ * @param {HTMLAttribute[]} attrs - Array of attribute objects with `name` property
+ * @param {boolean} caseSensitive - Whether to compare names case-sensitively (for XML/SVG)
+ * @returns {HTMLAttribute[]} Deduplicated attribute array (modifies in place and returns)
+ */
+declare function deduplicateAttributes(attrs: HTMLAttribute[], caseSensitive: boolean): HTMLAttribute[];
+/**
+ * @param {string} tag
+ * @param {HTMLAttribute[]} attrs
+ */
+declare function isExecutableScript(tag: string, attrs: HTMLAttribute[]): boolean;
+/**
+ * @param {string} tag
+ * @param {HTMLAttribute[]} attrs
+ */
+declare function isStyleElement(tag: string, attrs: HTMLAttribute[]): boolean;
+/**
+ * Whether a `meta` element has no effect in any current browser, holding no more than the
+ * `http-equiv` or `name` that says so, and `content`
+ * @param {HTMLAttribute[]} attrs - Deduplicated
+ * @param {string[]} markers - What custom fragment and `htmlmin:ignore` placeholders hold
+ */
+declare function isMetaWithoutEffect(attrs: HTMLAttribute[], markers: string[]): boolean;
+/**
+ * Replace a `meta` element’s `http-equiv=Content-Type` and `content` with the `charset` they
+ * declare, which browsers read the same
+ * @param {HTMLAttribute[]} attrs - Deduplicated; changed in place
+ * @param {string[]} markers - What custom fragment and `htmlmin:ignore` placeholders hold
+ */
+declare function replaceContentTypePragma(attrs: HTMLAttribute[], markers: string[]): void;
+/**
+ * @param {string} name
+ * @param {HTMLAttribute[]} attrs
+ */
+declare function hasAttrName(name: string, attrs: HTMLAttribute[]): boolean;
+/**
+ * @param {HTMLAttribute} attr
+ * @param {HTMLAttribute[]} attrs
+ * @param {string} tag
+ * @param {string} tagOut - The tag name as written, for hooks
+ * @param {ProcessedOptions} options
+ * @param {Function} minifyHTML
+ * @param {string[]} [markers] - What custom fragment and `htmlmin:ignore` placeholders hold
+ */
+declare function normalizeAttr(attr: HTMLAttribute, attrs: HTMLAttribute[], tag: string, tagOut: string, options: ProcessedOptions, minifyHTML: Function, markers?: string[]): Promise<{
+    attr: HTMLAttribute;
+    name: string;
+    value: string | undefined;
+} | undefined> | {
+    attr: HTMLAttribute;
+    name: string;
+    value: string | undefined;
+} | undefined;
+/**
+ * @param {{name: string, value: string | undefined, attr: HTMLAttribute}} normalized
+ * @param {string | boolean | undefined} hasUnarySlash
+ * @param {ProcessedOptions} options
+ * @param {boolean} isLast
+ * @param {string | undefined} uidAttr
+ */
+declare function buildAttr(normalized: {
+    name: string;
+    value: string | undefined;
+    attr: HTMLAttribute;
+}, hasUnarySlash: string | boolean | undefined, options: ProcessedOptions, isLast: boolean, uidAttr: string | undefined): string;
+export { isIgnoredComment, isExecutableScript, isStyleElement, isMetaWithoutEffect, hasAttrName, normalizeAttr, buildAttr, deduplicateAttributes, replaceContentTypePragma };
+//# sourceMappingURL=attributes.d.ts.map

package/dist/types/lib/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAAA;;GAEG;AAoCC,OAAQ,KAAA,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAGjD,YAA0I,aAAa,GAA7I;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAE1I;AA8BD;;;GAGG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EAHnB,MAGmB,EAAE,OAAO,EAF5B,gBAE4B,WAOtC;AAuCD;;;;;;;GAOG;AACH,iBAAS,qBAAqB,CAAC,KAAK,EAJzB,aAAa,EAIY,EAAE,aAAa,EAHxC,OAGwC,GAFtC,aAAa,EAAE,CAqB3B;AA4JD;;;GAGG;AACH,iBAAS,kBAAkB,CAAC,GAAG,EAHpB,MAGoB,EAAE,KAAK,EAF3B,aAAa,EAEc,WAUrC;AAOD;;;GAGG;AACH,iBAAS,cAAc,CAAC,GAAG,EAHhB,MAGgB,EAAE,KAAK,EAFvB,aAAa,EAEU,WAUjC;AA6JD;;;;;GAKG;AACH,iBAAS,mBAAmB,CAAC,KAAK,EAHvB,aAAa,EAGU,EAAE,OAAO,EAFhC,MAAM,EAE0B,WAkB1C;AA0BD;;;;;GAKG;AACH,iBAAS,wBAAwB,CAAC,KAAK,EAH5B,aAAa,EAGe,EAAE,OAAO,EAFrC,MAAM,EAE+B,QAe/C;AAmDD;;;GAGG;AACH,iBAAS,WAAW,CAAC,IAAI,EAHd,MAGc,EAAE,KAAK,EAFrB,aAAa,EAEQ,WAO/B;AAmUD;;;;;;;;GAQG;AACH,iBAAS,aAAa,CAAC,IAAI,EARhB,aAQgB,EAAE,KAAK,EAPvB,aAAa,EAOU,EAAE,GAAG,EAN5B,MAM4B,EAAE,MAAM,EALpC,MAKoC,EAAE,OAAO,EAJ7C,gBAI6C,EAAE,UAAU,UAAA,EAAE,OAAO,AAF1E,CACF,EADU,MAAM,EAE4D;;;;;;;;cAkB5E;AAsED;;;;;;GAMG;AACH,iBAAS,SAAS,CAAC,UAAU,EANlB;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAM3C,EAAE,aAAa,EALjC,MAAM,GAAG,OAAO,GAAG,SAKc,EAAE,OAAO,EAJ1C,gBAI0C,EAAE,MAAM,EAHlD,OAGkD,EAAE,OAAO,EAF3D,MAAM,GAAG,SAEkD,UA0HrE;AAED,OAAO,EAEL,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,WAAW,EAGX,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,wBAAwB,EACzB,CAAC"}

package/dist/types/lib/constants.d.ts

@@ -0,0 +1,421 @@
+/**
+ * Regex patterns, element sets, and default configuration
+ */
+declare const RE_WS_START: RegExp;
+declare const RE_WS_END: RegExp;
+declare const RE_WS_ONLY: RegExp;
+declare const RE_WS_NBSP_END: RegExp;
+declare const RE_ALL_WS_NBSP: RegExp;
+declare const RE_NBSP_LEADING_GROUP: RegExp;
+declare const RE_NBSP_LEAD_GROUP: RegExp;
+declare const RE_NBSP_TRAILING_GROUP: RegExp;
+declare const RE_NBSP_TRAILING_STRIP: RegExp;
+declare const RE_EVENT_ATTR_DEFAULT: RegExp;
+declare const RE_CAN_REMOVE_ATTR_QUOTES: RegExp;
+declare const RE_TRAILING_SEMICOLON: RegExp;
+declare const RE_CR: RegExp;
+declare const RE_LINE_BREAK_CR: RegExp;
+declare const RE_LEGACY_ENTITIES: RegExp;
+declare const RE_AMP_REFERENCE_ATTR: RegExp;
+declare const RE_ESCAPE_LT: RegExp;
+declare const RE_BASE_ELEMENT: RegExp;
+declare const RE_XML_ESCAPE_TEXT: RegExp;
+declare const RE_XML_ESCAPE_ATTR: RegExp;
+declare const RE_ESCAPE_LT_RAW_TEXT: Record<string, RegExp>;
+declare const RE_HTML_ENCODING: RegExp;
+declare const RE_DOCTYPE: RegExp;
+declare const RE_ATTR_WS_CHECK: RegExp;
+declare const RE_ATTR_WS_COLLAPSE: RegExp;
+declare const RE_WS_CHAR: RegExp;
+declare const RE_STYLE_ELEMENT: RegExp;
+declare const RE_EMPTY_ATTRIBUTE: RegExp;
+declare const inlineElementsToKeepWhitespaceAround: Set<string>;
+declare const inlineElementsToKeepWhitespaceWithin: Set<string>;
+declare const inlineElementsToKeepWhitespaceBetween: Set<string>;
+declare const inlineElementsTransparent: Set<string>;
+declare const processingInstructionTag = "?";
+declare const inlineElementsToKeepWhitespace: Set<string>;
+declare const formattingElements: Set<string>;
+/** @param {Iterable<string>} names */
+declare const toEndTags: (names: Iterable<string>) => Set<string>;
+declare const formControlElementsEither: Set<string>;
+declare const inlineElementsToKeepWhitespaceBetweenEnd: Set<string>;
+declare const inlineElementsTransparentAfter: Set<string>;
+declare const generalDefaults: {
+    autocorrect: string;
+    fetchpriority: string;
+    loading: string;
+    popovertargetaction: string;
+};
+declare const tagDefaults: {
+    area: {
+        shape: string;
+    };
+    button: {
+        type: string;
+    };
+    col: {
+        span: string;
+    };
+    colgroup: {
+        span: string;
+    };
+    form: {
+        autocomplete: string;
+        enctype: string;
+        method: string;
+    };
+    html: {
+        dir: string;
+    };
+    iframe: {
+        scrolling: string;
+    };
+    img: {
+        decoding: string;
+    };
+    input: {
+        colorspace: string;
+        type: string;
+    };
+    link: {
+        media: string;
+    };
+    marquee: {
+        behavior: string;
+        direction: string;
+    };
+    meta: {
+        media: string;
+    };
+    meter: {
+        max: string;
+        min: string;
+    };
+    ol: {
+        start: string;
+        type: string;
+    };
+    progress: {
+        max: string;
+    };
+    source: {
+        media: string;
+    };
+    style: {
+        media: string;
+    };
+    td: {
+        colspan: string;
+        rowspan: string;
+    };
+    textarea: {
+        cols: string;
+        rows: string;
+        wrap: string;
+    };
+    th: {
+        colspan: string;
+        rowspan: string;
+        scope: string;
+    };
+    track: {
+        kind: string;
+    };
+};
+declare const integrationPointsForeign: {
+    svg: Set<string>;
+    math: Set<string>;
+};
+declare const metaHttpEquivNoEffect: Set<string>;
+declare const metaNamesNoEffect: Set<string>;
+declare const targetSelfElements: Set<string>;
+declare const tagDefaultsSVG: {
+    animatemotion: {
+        rotate: string;
+    };
+    animatetransform: {
+        type: string;
+    };
+    circle: {
+        cx: string;
+        cy: string;
+    };
+    clippath: {
+        clippathunits: string;
+    };
+    ellipse: {
+        cx: string;
+        cy: string;
+    };
+    feblend: {
+        mode: string;
+    };
+    fecolormatrix: {
+        type: string;
+    };
+    fecomposite: {
+        k1: string;
+        k2: string;
+        k3: string;
+        k4: string;
+        operator: string;
+    };
+    feconvolvematrix: {
+        bias: string;
+        edgemode: string;
+        order: string;
+        preservealpha: string;
+    };
+    fediffuselighting: {
+        diffuseconstant: string;
+        surfacescale: string;
+    };
+    fedisplacementmap: {
+        scale: string;
+        xchannelselector: string;
+        ychannelselector: string;
+    };
+    fedistantlight: {
+        azimuth: string;
+        elevation: string;
+    };
+    fedropshadow: {
+        dx: string;
+        dy: string;
+        stddeviation: string;
+    };
+    fefunca: {
+        amplitude: string;
+        exponent: string;
+        intercept: string;
+        offset: string;
+        slope: string;
+        type: string;
+    };
+    fefuncb: {
+        amplitude: string;
+        exponent: string;
+        intercept: string;
+        offset: string;
+        slope: string;
+        type: string;
+    };
+    fefuncg: {
+        amplitude: string;
+        exponent: string;
+        intercept: string;
+        offset: string;
+        slope: string;
+        type: string;
+    };
+    fefuncr: {
+        amplitude: string;
+        exponent: string;
+        intercept: string;
+        offset: string;
+        slope: string;
+        type: string;
+    };
+    fegaussianblur: {
+        stddeviation: string;
+    };
+    feimage: {
+        preserveaspectratio: string;
+    };
+    femorphology: {
+        operator: string;
+        radius: string;
+    };
+    feoffset: {
+        dx: string;
+        dy: string;
+    };
+    fepointlight: {
+        x: string;
+        y: string;
+        z: string;
+    };
+    fespecularlighting: {
+        specularconstant: string;
+        specularexponent: string;
+        surfacescale: string;
+    };
+    fespotlight: {
+        pointsatx: string;
+        pointsaty: string;
+        pointsatz: string;
+        specularexponent: string;
+        x: string;
+        y: string;
+        z: string;
+    };
+    feturbulence: {
+        basefrequency: string;
+        numoctaves: string;
+        seed: string;
+        stitchtiles: string;
+        type: string;
+    };
+    filter: {
+        filterunits: string;
+        height: string;
+        primitiveunits: string;
+        width: string;
+        x: string;
+        y: string;
+    };
+    foreignobject: {
+        x: string;
+        y: string;
+    };
+    image: {
+        preserveaspectratio: string;
+        x: string;
+        y: string;
+    };
+    line: {
+        x1: string;
+        x2: string;
+        y1: string;
+        y2: string;
+    };
+    lineargradient: {
+        gradientunits: string;
+        spreadmethod: string;
+        x1: string[];
+        x2: string;
+        y1: string[];
+        y2: string[];
+    };
+    marker: {
+        markerheight: string;
+        markerunits: string;
+        markerwidth: string;
+        orient: string;
+        preserveaspectratio: string;
+        refx: string;
+        refy: string;
+    };
+    mask: {
+        height: string;
+        maskcontentunits: string;
+        maskunits: string;
+        width: string;
+        x: string;
+        y: string;
+    };
+    pattern: {
+        height: string;
+        patterncontentunits: string;
+        patternunits: string;
+        preserveaspectratio: string;
+        width: string;
+        x: string;
+        y: string;
+    };
+    radialgradient: {
+        cx: string;
+        cy: string;
+        fr: string[];
+        gradientunits: string;
+        r: string;
+        spreadmethod: string;
+    };
+    rect: {
+        x: string;
+        y: string;
+    };
+    stop: {
+        offset: string;
+    };
+    svg: {
+        preserveaspectratio: string;
+        version: string;
+        x: string;
+        y: string;
+    };
+    symbol: {
+        preserveaspectratio: string;
+    };
+    text: {
+        lengthadjust: string;
+        x: string;
+        y: string;
+    };
+    textpath: {
+        lengthadjust: string;
+        method: string;
+        spacing: string;
+        startoffset: string;
+    };
+    tspan: {
+        lengthadjust: string;
+    };
+    use: {
+        x: string;
+        y: string;
+    };
+    view: {
+        preserveaspectratio: string;
+    };
+};
+declare const svgElementsInheritingByReference: Set<string>;
+declare const namespaceHTML = "http://www.w3.org/1999/xhtml";
+declare const namespaceSVG = "http://www.w3.org/2000/svg";
+declare const namespaceMathML = "http://www.w3.org/1998/Math/MathML";
+declare const namespaceXLink = "http://www.w3.org/1999/xlink";
+declare const executableScriptsMimetypes: Set<string>;
+declare const keepScriptsMimetypes: Set<string>;
+declare const isSimpleBoolean: Set<string>;
+declare const isBooleanValue: Set<string>;
+declare const collapsibleValues: Map<string, Set<string>>;
+declare const srcsetElements: Set<string>;
+declare const jsonScriptTypes: Set<string>;
+declare const optionalStartTags: Set<string>;
+declare const optionalEndTags: Set<string>;
+declare const headerElements: Set<string>;
+declare const descriptionElements: Set<string>;
+declare const pBlockElements: Set<string>;
+declare const pClosingParents: Set<string>;
+declare const rubyEndTagOmission: Set<string>;
+declare const rubyRtcEndTagOmission: Set<string>;
+declare const optionElements: Set<string>;
+declare const tableContentElements: Set<string>;
+declare const tableSectionElements: Set<string>;
+declare const cellElements: Set<string>;
+declare const topLevelElements: Set<string>;
+declare const compactElements: Set<string>;
+declare const looseElements: Set<string>;
+declare const trailingElements: Set<string>;
+declare const htmlElements: Set<string>;
+declare const quirksPublicIds: Set<string>;
+declare const quirksSystemIds: Set<string>;
+declare const quirksPublicIdPrefixes: string[];
+declare const quirksPublicIdPrefixesNoSystemId: string[];
+declare const specialContentElements: Set<string>;
+declare const genericRawTextElements: Set<string>;
+declare const endlessRawTextElements: Set<string>;
+declare const escapableRawTextElements: Set<string>;
+declare const rawTextElements: Set<string>;
+declare const MISSING_DEPENDENCY = "HM_MISSING_DEPENDENCY";
+declare const svgoPluginsInline: {
+    name: string;
+    params: {
+        overrides: {
+            cleanupIds: boolean;
+            inlineStyles: boolean;
+            minifyStyles: {
+                usage: boolean;
+            };
+            removeEmptyAttrs: boolean;
+            removeHiddenElems: boolean;
+            removeUnknownsAndDefaults: {
+                keepRoleAttr: boolean;
+            };
+        };
+    };
+}[];
+declare const namesForeignMixedCase: Map<string, string>;
+export { RE_WS_START, RE_WS_END, RE_WS_ONLY, RE_WS_NBSP_END, RE_ALL_WS_NBSP, RE_NBSP_LEADING_GROUP, RE_NBSP_LEAD_GROUP, RE_NBSP_TRAILING_GROUP, RE_NBSP_TRAILING_STRIP, RE_EVENT_ATTR_DEFAULT, RE_CAN_REMOVE_ATTR_QUOTES, RE_TRAILING_SEMICOLON, RE_AMP_REFERENCE_ATTR, RE_CR, RE_LINE_BREAK_CR, RE_LEGACY_ENTITIES, RE_ESCAPE_LT, RE_BASE_ELEMENT, RE_ESCAPE_LT_RAW_TEXT, RE_XML_ESCAPE_TEXT, RE_XML_ESCAPE_ATTR, RE_HTML_ENCODING, RE_DOCTYPE, RE_ATTR_WS_CHECK, RE_ATTR_WS_COLLAPSE, RE_WS_CHAR, RE_STYLE_ELEMENT, RE_EMPTY_ATTRIBUTE, formattingElements, inlineElementsToKeepWhitespaceAround, inlineElementsToKeepWhitespaceWithin, inlineElementsToKeepWhitespaceBetween, inlineElementsToKeepWhitespaceBetweenEnd, inlineElementsTransparent, inlineElementsTransparentAfter, inlineElementsToKeepWhitespace, processingInstructionTag, formControlElementsEither, toEndTags, generalDefaults, tagDefaults, metaHttpEquivNoEffect, metaNamesNoEffect, targetSelfElements, integrationPointsForeign, tagDefaultsSVG, svgElementsInheritingByReference, namespaceHTML, namespaceSVG, namespaceMathML, namespaceXLink, executableScriptsMimetypes, keepScriptsMimetypes, jsonScriptTypes, isSimpleBoolean, isBooleanValue, collapsibleValues, srcsetElements, MISSING_DEPENDENCY, namesForeignMixedCase, svgoPluginsInline, optionalStartTags, optionalEndTags, headerElements, descriptionElements, pBlockElements, pClosingParents, rubyEndTagOmission, rubyRtcEndTagOmission, optionElements, tableContentElements, tableSectionElements, cellElements, topLevelElements, compactElements, looseElements, trailingElements, htmlElements, quirksPublicIds, quirksSystemIds, quirksPublicIdPrefixes, quirksPublicIdPrefixesNoSystemId, specialContentElements, genericRawTextElements, endlessRawTextElements, escapableRawTextElements, rawTextElements };
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"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"}

package/dist/types/lib/content.d.ts

@@ -0,0 +1,44 @@
+/**
+ * CSS and script content wrapping for minification
+ */
+import type { ProcessedOptions } from './options.js';
+/** @import { ProcessedOptions } from './options.js' */
+/**
+ * @param {string} text
+ * @param {string} [type]
+ */
+declare function wrapCSS(text: string, type?: string): string;
+/**
+ * @param {string} text
+ * @param {string} [type]
+ */
+declare function unwrapCSS(text: string, type?: string): string;
+/** @param {Array<{name: string, value?: string}>} attrs */
+declare function hasJsonScriptType(attrs: Array<{
+    name: string;
+    value?: string;
+}>): boolean;
+/**
+ * @param {string} text
+ * @param {ProcessedOptions} options
+ * @param {string} tag
+ * @param {Array<{name: string, value?: string | undefined}>} currentAttrs
+ * @param {Function} minifyHTML
+ */
+declare function processScript(text: string, options: ProcessedOptions, tag: string, currentAttrs: Array<{
+    name: string;
+    value?: string | undefined;
+}>, minifyHTML: Function): Promise<any>;
+/**
+ * Collects the bodies of executable inline scripts, in document order, so they can be
+ * minified as one batch ahead of the parse. Duplicates are dropped: The minifier is
+ * content-keyed, so the same body only needs dispatching once.
+ * @param {string} html
+ * @returns {Array<{code: string, isModule: boolean}>}
+ */
+declare function extractScriptBodies(html: string): Array<{
+    code: string;
+    isModule: boolean;
+}>;
+export { wrapCSS, unwrapCSS, hasJsonScriptType, extractScriptBodies, processScript };
+//# sourceMappingURL=content.d.ts.map

package/dist/types/lib/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/lib/content.js"],"names":[],"mappings":"AAAA;;GAEG;AAUC,OAAQ,KAAA,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAApD,uDAAuD;AAKvD;;;GAGG;AACH,iBAAS,OAAO,CAAC,IAAI,EAHV,MAGU,EAAE,IAAI,AAFxB,CAAsB,EAAd,MAEgB,UAS1B;AAED;;;GAGG;AACH,iBAAS,SAAS,CAAC,IAAI,EAHZ,MAGY,EAAE,IAAI,AAF1B,CAAsB,EAAd,MAEkB,UAW5B;AAyED,2DAA2D;AAC3D,iBAAS,iBAAiB,CAAC,KAAK,EADpB,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAChB,WAU/B;AAED;;;;;;GAMG;AACH,iBAAe,aAAa,CAAC,IAAI,EANtB,MAMsB,EAAE,OAAO,EAL/B,gBAK+B,EAAE,GAAG,EAJpC,MAIoC,EAAE,YAAY,EAHlD,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAC,CAGE,EAAE,UAAU,UAAA,gBAexE;AAWD;;;;;;GAMG;AACH,iBAAS,mBAAmB,CAAC,IAAI,EAHtB,MAGsB,GAFpB,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAC,CAAC,CAsDpD;AAED,OAAO,EAEL,OAAO,EACP,SAAS,EAGT,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACd,CAAC"}

package/dist/types/lib/elements.d.ts

@@ -0,0 +1,48 @@
+/**
+ * HTML element tag omission rules
+ */
+import type { HTMLAttribute } from './attributes.js';
+import type { ProcessedOptions } from './options.js';
+/** @import { HTMLAttribute } from './attributes.js' */
+/** @import { ProcessedOptions } from './options.js' */
+/**
+ * @param {string} optionalStartTag
+ * @param {string} tag
+ */
+declare function canRemoveParentTag(optionalStartTag: string, tag: string): boolean;
+/**
+ * @param {string} optionalEndTag
+ * @param {string} tag
+ */
+declare function isStartTagMandatory(optionalEndTag: string, tag: string): boolean;
+/**
+ * @param {string} optionalEndTag
+ * @param {string} tag
+ */
+declare function canRemovePrecedingTag(optionalEndTag: string, tag: string): boolean;
+/**
+ * @param {string} tag
+ * @param {HTMLAttribute[]} attrs
+ */
+declare function canRemoveElement(tag: string, attrs: HTMLAttribute[]): boolean;
+/**
+ * @param {string[]} input - Array of element specifications from `removeEmptyElementsExcept` option
+ * @param {ProcessedOptions} options - Options object for parsing
+ * @returns {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} Array of parsed element specs
+ */
+declare function parseRemoveEmptyElementsExcept(input: string[], options: ProcessedOptions): Array<{
+    tag: string;
+    attrs: Record<string, string | undefined> | null;
+}>;
+/**
+ * @param {string} tag - Element tag name
+ * @param {HTMLAttribute[]} attrs - Array of element attributes
+ * @param {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} preserveList - Parsed preserve specs
+ * @returns {boolean} True if the empty element should be preserved
+ */
+declare function shouldPreserveEmptyElement(tag: string, attrs: HTMLAttribute[], preserveList: Array<{
+    tag: string;
+    attrs: Record<string, string | undefined> | null;
+}>): boolean;
+export { canRemoveParentTag, isStartTagMandatory, canRemovePrecedingTag, canRemoveElement, parseRemoveEmptyElementsExcept, shouldPreserveEmptyElement };
+//# sourceMappingURL=elements.d.ts.map

package/dist/types/lib/elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elements.d.ts","sourceRoot":"","sources":["../../../src/lib/elements.js"],"names":[],"mappings":"AAAA;;GAEG;AAeC,OAAQ,KAAA,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAQ,KAAA,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AADpD,uDAAuD;AACvD,uDAAuD;AAEvD;;;GAGG;AACH,iBAAS,kBAAkB,CAAC,gBAAgB,EAHjC,MAGiC,EAAE,GAAG,EAFtC,MAEsC,WAahD;AAED;;;GAGG;AACH,iBAAS,mBAAmB,CAAC,cAAc,EAHhC,MAGgC,EAAE,GAAG,EAFrC,MAEqC,WAQ/C;AAED;;;GAGG;AACH,iBAAS,qBAAqB,CAAC,cAAc,EAHlC,MAGkC,EAAE,GAAG,EAFvC,MAEuC,WAmCjD;AAED;;;GAGG;AACH,iBAAS,gBAAgB,CAAC,GAAG,EAHlB,MAGkB,EAAE,KAAK,EAFzB,aAAa,EAEY,WAuDnC;AAiDD;;;;GAIG;AACH,iBAAS,8BAA8B,CAAC,KAAK,EAJlC,MAAM,EAI4B,EAAE,OAAO,EAH3C,gBAG2C,GAFzC,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,qCAAkC,IAAI,CAAA;CAAC,CAAC,CAc/E;AAED;;;;;GAKG;AACH,iBAAS,0BAA0B,CAAC,GAAG,EAL5B,MAK4B,EAAE,KAAK,EAJnC,aAAa,EAIsB,EAAE,YAAY,EAHjD,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,qCAAkC,IAAI,CAAA;CAAC,CAGjB,GAF/C,OAAO,CA8BnB;AAED,OAAO,EAEL,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EAGrB,gBAAgB,EAChB,8BAA8B,EAC9B,0BAA0B,EAC3B,CAAC"}

package/dist/types/lib/fragments.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Custom fragment matching
+ *
+ * `ignoreCustomFragments` patterns nearly always describe the same shape: a literal
+ * opening delimiter, an any-character or negated-class body, and a literal closing
+ * delimiter, as in `<%[\s\S]*?%>` or `\{\{[^}]*?\}\}`. Such a fragment can be found
+ * with `indexOf` in linear time, where running the pattern as a regex costs O(n²)
+ * on input that opens fragments it never closes—and can cost far more than that when
+ * the pattern itself backtracks. Patterns of other shapes keep running as regexes,
+ * one per pattern, so each keeps its own flags.
+ */
+export type DelimitedFragment = {
+    open: string;
+    close: string;
+    min: number;
+    max: number;
+    excluded: RegExp | null;
+};
+export type PatternFragment = {
+    search: RegExp;
+    anchored: RegExp;
+    close: string | null;
+};
+/**
+ * Describe a fragment pattern as literal delimiters around an any-character body
+ * @param {RegExp} pattern
+ * @returns {DelimitedFragment | null} Null when the pattern has another shape, which
+ *  the caller answers by running it as a regex
+ */
+declare function toDelimitedFragment(pattern: RegExp): DelimitedFragment | null;
+/**
+ * Prepare a fragment pattern for matching, by scanning where the shape allows it
+ * @param {RegExp} pattern
+ * @returns {DelimitedFragment | PatternFragment}
+ */
+declare function toFragment(pattern: RegExp): DelimitedFragment | PatternFragment;
+/**
+ * Replace runs of custom fragments, and the whitespace padding them
+ * @param {string} value - Document to scan
+ * @param {(DelimitedFragment | PatternFragment)[]} fragments - In the order the patterns
+ *  were given, since the earliest match wins and ties go to the pattern listed first
+ * @param {(match: string) => string} replacer - Called with each match, as `replace` would
+ * @returns {string}
+ */
+declare function replaceCustomFragments(value: string, fragments: (DelimitedFragment | PatternFragment)[], replacer: (match: string) => string): string;
+export { toDelimitedFragment, toFragment, replaceCustomFragments };
+//# sourceMappingURL=fragments.d.ts.map

package/dist/types/lib/fragments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragments.d.ts","sourceRoot":"","sources":["../../../src/lib/fragments.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAaA,YAA4F,iBAAiB,GAAnG;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAC,CAI1F;AAAA,YAAoE,eAAe,GAAzE;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAC,CAGpE;AAmCD;;;;;GAKG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAJzB,MAIyB,GAHvB,iBAAiB,GAAG,IAAI,CAwBpC;AA8CD;;;;GAIG;AACH,iBAAS,UAAU,CAAC,OAAO,EAHhB,MAGgB,GAFd,iBAAiB,GAAG,eAAe,CAa/C;AAED;;;;;;;GAOG;AACH,iBAAS,sBAAsB,CAAC,KAAK,EAN1B,MAM0B,EAAE,SAAS,EALrC,CAAC,iBAAiB,GAAG,eAAe,CAAC,EAKA,EAAE,QAAQ,EAH/C,CAAC,KAAK,EAAE,MAAM,KAAK,MAG4B,GAF7C,MAAM,CA2KlB;AAED,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,sBAAsB,EACvB,CAAC"}