html-minifier-next 4.0.2 → 4.1.1

package/dist/types/htmlminifier.d.ts

@@ -0,0 +1,382 @@
+export function minify(value: string, options?: MinifierOptions): Promise<string>;
+declare namespace _default {
+    export { minify };
+}
+export default _default;
+/**
+ * Representation of an attribute from the HTML parser.
+ */
+export type HTMLAttribute = {
+    name: string;
+    value?: string;
+    quote?: string;
+    customAssign?: string;
+    customOpen?: string;
+    customClose?: string;
+};
+/**
+ * Options that control how HTML is minified. All of these are optional
+ * and usually default to a disabled/safe value unless noted.
+ */
+export type MinifierOptions = {
+    /**
+     * Predicate that determines whether whitespace inside a given element
+     * can be collapsed.
+     *
+     * Default: Built-in `canCollapseWhitespace` function
+     */
+    canCollapseWhitespace?: (tag: string, attrs: HTMLAttribute[], canCollapseWhitespace: (tag: string) => boolean) => boolean;
+    /**
+     * Predicate that determines whether leading/trailing whitespace around
+     * the element may be trimmed.
+     *
+     * Default: Built-in `canTrimWhitespace` function
+     */
+    canTrimWhitespace?: (tag: string | null, attrs: HTMLAttribute[] | undefined, canTrimWhitespace: (tag: string) => boolean) => boolean;
+    /**
+     * When true, tag and attribute names are treated as case-sensitive.
+     * Useful for custom HTML tags.
+     * If false (default) names are lower-cased via the `name` function.
+     *
+     * Default: `false`
+     */
+    caseSensitive?: boolean;
+    /**
+     * Collapse boolean attributes to their name only (for example
+     * `disabled="disabled"` -> `disabled`).
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
+     *
+     * Default: `false`
+     */
+    collapseBooleanAttributes?: boolean;
+    /**
+     * When false (default) whitespace around `inline` tags is preserved in
+     * more cases. When true, whitespace around inline tags may be collapsed.
+     * Must also enable `collapseWhitespace` to have effect.
+     *
+     * Default: `false`
+     */
+    collapseInlineTagWhitespace?: boolean;
+    /**
+     * Collapse multiple whitespace characters into one where allowed. Also
+     * controls trimming behaviour in several code paths.
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace
+     *
+     * Default: `false`
+     */
+    collapseWhitespace?: boolean;
+    /**
+     * If true, be conservative when collapsing whitespace (preserve more
+     * whitespace in edge cases). Affects collapse algorithms.
+     * Must also enable `collapseWhitespace` to have effect.
+     *
+     * Default: `false`
+     */
+    conservativeCollapse?: boolean;
+    /**
+     * When true, the parser will attempt to continue on recoverable parse
+     * errors. Otherwise, parsing errors may throw.
+     *
+     * Default: `false`
+     */
+    continueOnParseError?: boolean;
+    /**
+     * Array of regexes used to recognise custom attribute assignment
+     * operators (e.g. `'<div flex?="{{mode != cover}}"></div>'`).
+     * These are concatenated with the built-in assignment patterns.
+     *
+     * Default: `[]`
+     */
+    customAttrAssign?: RegExp[];
+    /**
+     * Regex matching attribute names whose values should be collapsed.
+     * Basically used to remove newlines and excess spaces inside attribute values,
+     * e.g. `/ng-class/`.
+     */
+    customAttrCollapse?: RegExp;
+    /**
+     * Array of `[openRegExp, closeRegExp]` pairs used by the parser to
+     * detect custom attribute surround patterns (for non-standard syntaxes,
+     * e.g. `<input {{#if value}}checked="checked"{{/if}}>`).
+     */
+    customAttrSurround?: [RegExp, RegExp][];
+    /**
+     * Array of regexes used to detect event handler attributes for `minifyJS`
+     * (e.g. `ng-click`). The default matches standard `on…` event attributes.
+     *
+     * Default: `[/^on[a-z]{3,}$/]`
+     */
+    customEventAttributes?: RegExp[];
+    /**
+     * Limits the quantifier used when building a safe regex for custom
+     * fragments to avoid ReDoS. See source use for details.
+     *
+     * Default: `200`
+     */
+    customFragmentQuantifierLimit?: number;
+    /**
+     * When true, decodes HTML entities in text and attributes before
+     * processing, and re-encodes ambiguous ampersands when outputting.
+     *
+     * Default: `false`
+     */
+    decodeEntities?: boolean;
+    /**
+     * Parse and emit using HTML5 rules. Set to `false` to use non-HTML5
+     * parsing behavior.
+     *
+     * Default: `true`
+     */
+    html5?: boolean;
+    /**
+     * Comments matching any pattern in this array of regexes will be
+     * preserved when `removeComments` is enabled. The default preserves
+     * “bang” comments and comments starting with `#`.
+     *
+     * Default: `[/^!/, /^\s*#/]`
+     */
+    ignoreCustomComments?: RegExp[];
+    /**
+     * Array of regexes used to identify fragments that should be
+     * preserved (for example server templates). These fragments are temporarily
+     * replaced during minification to avoid corrupting template code.
+     * The default preserves ASP/PHP-style tags.
+     *
+     * Default: `[/<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/]`
+     */
+    ignoreCustomFragments?: RegExp[];
+    /**
+     * If false, tags marked as auto-generated by the parser will be omitted
+     * from output. Useful to skip injected tags.
+     *
+     * Default: `true`
+     */
+    includeAutoGeneratedTags?: boolean;
+    /**
+     * Collection of custom element tag names that should be treated as inline
+     * elements for white-space handling, alongside the built-in inline elements.
+     *
+     * Default: `[]`
+     */
+    inlineCustomElements?: ArrayLike<string>;
+    /**
+     * Preserve the trailing slash in self-closing tags when present.
+     *
+     * Default: `false`
+     */
+    keepClosingSlash?: boolean;
+    /**
+     * Logging function used by the minifier for warnings/errors/info.
+     * You can directly provide `console.log`, but `message` may also be an `Error`
+     * object or other non-string value.
+     *
+     * Default: `() => {}` (no-op function)
+     */
+    log?: (message: unknown) => void;
+    /**
+     * The maximum allowed input length. Used as a guard against ReDoS via
+     * pathological inputs. If the input exceeds this length an error is
+     * thrown.
+     *
+     * Default: No limit
+     */
+    maxInputLength?: number;
+    /**
+     * Maximum line length for the output. When set the minifier will wrap
+     * output to the given number of characters where possible.
+     *
+     * Default: No limit
+     */
+    maxLineLength?: number;
+    /**
+     * When true, enables CSS minification for inline `<style>` tags or
+     * `style` attributes. If an object is provided, it is passed to
+     * [Lightning CSS](https://www.npmjs.com/package/lightningcss)
+     * as transform options. If a function is provided, it will be used to perform
+     * custom CSS minification. If disabled, CSS is not minified.
+     *
+     * Default: `false`
+     */
+    minifyCSS?: boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string);
+    /**
+     * When true, enables JS minification for `<script>` contents and
+     * event handler attributes. If an object is provided, it is passed to
+     * [terser](https://www.npmjs.com/package/terser) as minify options.
+     * If a function is provided, it will be used to perform
+     * custom JS minification. If disabled, JS is not minified.
+     *
+     * Default: `false`
+     */
+    minifyJS?: boolean | import("terser").MinifyOptions | ((text: string, inline?: boolean) => Promise<string> | string);
+    /**
+     * When true, enables URL rewriting/minification. If an object is provided,
+     * it is passed to [relateurl](https://www.npmjs.com/package/relateurl)
+     * as options. If a string is provided, it is treated as an `{ site: string }`
+     * options object. If a function is provided, it will be used to perform
+     * custom URL minification. If disabled, URLs are not minified.
+     *
+     * Default: `false`
+     */
+    minifyURLs?: boolean | string | import("relateurl").Options | ((text: string) => Promise<string> | string);
+    /**
+     * Function used to normalise tag/attribute names. By default, this lowercases
+     * names, unless `caseSensitive` is enabled.
+     *
+     * Default: `(name) => name.toLowerCase()`,
+     * or `(name) => name` (no-op function) if `caseSensitive` is enabled.
+     */
+    name?: (name: string) => string;
+    /**
+     * When wrapping lines, prevent inserting a newline directly before a
+     * closing tag (useful to keep tags like `</a>` on the same line).
+     *
+     * Default: `false`
+     */
+    noNewlinesBeforeTagClose?: boolean;
+    /**
+     * Preserve a single line break at the start/end of text nodes when
+     * collapsing/trimming whitespace.
+     * Must also enable `collapseWhitespace` to have effect.
+     *
+     * Default: `false`
+     */
+    preserveLineBreaks?: boolean;
+    /**
+     * When true, attribute values will not be HTML-escaped (dangerous for
+     * untrusted input). By default, attributes are escaped.
+     *
+     * Default: `false`
+     */
+    preventAttributesEscaping?: boolean;
+    /**
+     * When true, conditional comments (for example `<!--[if IE]> … <![endif]-->`)
+     * will have their inner content processed by the minifier.
+     * Useful to minify HTML that appears inside conditional comments.
+     *
+     * Default: `false`
+     */
+    processConditionalComments?: boolean;
+    /**
+     * Array of `type` attribute values for `<script>` elements whose contents
+     * should be processed as HTML
+     * (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.).
+     * When present, the contents of matching script tags are recursively minified,
+     * like normal HTML content.
+     *
+     * Default: `[]`
+     */
+    processScripts?: string[];
+    /**
+     * Preferred quote character for attribute values. If unspecified the
+     * minifier picks the safest quote based on the attribute value.
+     *
+     * Default: Auto-detected
+     */
+    quoteCharacter?: "\"" | "'";
+    /**
+     * Remove quotes around attribute values where it is safe to do so.
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_attribute_quotes
+     *
+     * Default: `false`
+     */
+    removeAttributeQuotes?: boolean;
+    /**
+     * Remove HTML comments. Comments that match `ignoreCustomComments` will
+     * still be preserved.
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_comments
+     *
+     * Default: `false`
+     */
+    removeComments?: boolean;
+    /**
+     * If true, removes attributes whose values are empty (some attributes
+     * are excluded by name). Can also be a function to customise which empty
+     * attributes are removed.
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_or_blank_attributes
+     *
+     * Default: `false`
+     */
+    removeEmptyAttributes?: boolean | ((attrName: string, tag: string) => boolean);
+    /**
+     * Remove elements that are empty and safe to remove (for example
+     * `<script />` without `src`).
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_elements
+     *
+     * Default: `false`
+     */
+    removeEmptyElements?: boolean;
+    /**
+     * Drop optional start/end tags where the HTML specification permits it
+     * (for example `</li>`, optional `<html>` etc.).
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_optional_tags
+     *
+     * Default: `false`
+     */
+    removeOptionalTags?: boolean;
+    /**
+     * Remove attributes that are redundant because they match the element's
+     * default values (for example `<button type="submit">`).
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_redundant_attributes
+     *
+     * Default: `false`
+     */
+    removeRedundantAttributes?: boolean;
+    /**
+     * Remove `type` attributes from `<script>` when they are unnecessary
+     * (e.g. `type="text/javascript"`).
+     *
+     * Default: `false`
+     */
+    removeScriptTypeAttributes?: boolean;
+    /**
+     * Remove `type` attributes from `<style>` and `<link>` elements when
+     * they are unnecessary (e.g. `type="text/css"`).
+     *
+     * Default: `false`
+     */
+    removeStyleLinkTypeAttributes?: boolean;
+    /**
+     * **Note that this will currently result in invalid HTML!**
+     *
+     * When true, extra whitespace between tag name and attributes (or before
+     * the closing bracket) will be removed where possible. Affects output spacing
+     * such as the space used in the short doctype representation.
+     *
+     * Default: `false`
+     */
+    removeTagWhitespace?: boolean;
+    /**
+     * When true, enables sorting of attributes. If a function is provided it
+     * will be used as a custom attribute sorter, which should mutate `attrs`
+     * in-place to the desired order. If disabled, the minifier will attempt to
+     * preserve the order from the input.
+     *
+     * Default: `false`
+     */
+    sortAttributes?: boolean | ((tag: string, attrs: HTMLAttribute[]) => void);
+    /**
+     * When true, enables sorting of class names inside `class` attributes.
+     * If a function is provided it will be used to transform/sort the class
+     * name string. If disabled, the minifier will attempt to preserve the
+     * class-name order from the input.
+     *
+     * Default: `false`
+     */
+    sortClassName?: boolean | ((value: string) => string);
+    /**
+     * When true, whitespace around ignored custom fragments may be trimmed
+     * more aggressively. This affects how preserved fragments interact with
+     * surrounding whitespace collapse.
+     *
+     * Default: `false`
+     */
+    trimCustomFragments?: boolean;
+    /**
+     * Replace the HTML doctype with the short `<!doctype html>` form.
+     * See also: https://perfectionkills.com/experimenting-with-html-minifier/#use_short_doctype
+     *
+     * Default: `false`
+     */
+    useShortDoctype?: boolean;
+};
+//# sourceMappingURL=htmlminifier.d.ts.map

package/dist/types/htmlminifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAm7CO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;UAQS,MAAM;YACN,MAAM;YACN,MAAM;mBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;4BAQN,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;wBAMjG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;;kCAOP,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;2BAOP,OAAO;;;;;;;2BAOP,OAAO;;;;;;;;uBAMP,MAAM,EAAE;;;;;;yBAOR,MAAM;;;;;;yBAKN,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;;;4BAKlB,MAAM,EAAE;;;;;;;oCAMR,MAAM;;;;;;;qBAMN,OAAO;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,MAAM,EAAE;;;;;;;;;4BAOR,MAAM,EAAE;;;;;;;+BAQR,OAAO;;;;;;;2BAMP,SAAS,CAAC,MAAM,CAAC;;;;;;uBAMjB,OAAO;;;;;;;;UAKP,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;;;;;;;;qBAO1B,MAAM;;;;;;;oBAON,MAAM;;;;;;;;;;gBAMN,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;eAS9J,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;;+BAOxB,OAAO;;;;;;;;yBAMP,OAAO;;;;;;;gCAOP,OAAO;;;;;;;;iCAMP,OAAO;;;;;;;;;;qBAOP,MAAM,EAAE;;;;;;;qBASR,IAAI,GAAG,GAAG;;;;;;;4BAMV,OAAO;;;;;;;;qBAMP,OAAO;;;;;;;;;4BAOP,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;;;;;;;;0BAQtD,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;iCAOP,OAAO;;;;;;;oCAMP,OAAO;;;;;;;;;;0BAMP,OAAO;;;;;;;;;qBASP,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO"}

package/dist/types/htmlparser.d.ts

@@ -0,0 +1,8 @@
+export const endTag: RegExp;
+export class HTMLParser {
+    constructor(html: any, handler: any);
+    html: any;
+    handler: any;
+    parse(): Promise<void>;
+}
+//# sourceMappingURL=htmlparser.d.ts.map

package/dist/types/htmlparser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAgDA,4BAAoE;AAyDpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBA2VC;CACF"}

package/dist/types/tokenchain.d.ts

@@ -0,0 +1,9 @@
+export default TokenChain;
+declare class TokenChain {
+    add(tokens: any): void;
+    createSorter(): Sorter;
+}
+declare class Sorter {
+    sort(tokens: any, fromIndex?: number): any;
+}
+//# sourceMappingURL=tokenchain.d.ts.map

package/dist/types/tokenchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenchain.d.ts","sourceRoot":"","sources":["../../src/tokenchain.js"],"names":[],"mappings":";AAwBA;IACE,uBASC;IAED,uBA4BC;CACF;AAjED;IACE,2CAoBC;CACF"}

package/dist/types/utils.d.ts

@@ -0,0 +1,2 @@
+export function replaceAsync(str: any, regex: any, asyncFn: any): Promise<any>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.js"],"names":[],"mappings":"AAAA,+EAUC"}

package/package.json

@@ -5,6 +5,7 @@
   },
   "bugs": "https://github.com/j9t/html-minifier-next/issues",
   "dependencies": {
+    "@types/relateurl": "^0.2.33",
     "change-case": "^4.1.2",
     "commander": "^14.0.2",
     "entities": "^7.0.0",
@@ -15,18 +16,20 @@
   "description": "Highly configurable, well-tested, JavaScript-based HTML minifier",
   "devDependencies": {
     "@commitlint/cli": "^20.1.0",
-    "@eslint/js": "^9.37.0",
-    "@rollup/plugin-commonjs": "^28.0.9",
+    "@eslint/js": "^9.39.1",
+    "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "eslint": "^9.37.0",
+    "eslint": "^9.39.1",
     "rollup": "^4.52.5",
     "rollup-plugin-polyfill-node": "^0.13.0",
+    "typescript": "^5.9.3",
     "vite": "^7.1.12"
   },
   "exports": {
     ".": {
+      "types": "./dist/types/htmlminifier.d.ts",
       "import": "./src/htmlminifier.js",
       "require": "./dist/htmlminifier.cjs"
     },
@@ -64,19 +67,22 @@
   "license": "MIT",
   "main": "./dist/htmlminifier.cjs",
   "module": "./src/htmlminifier.js",
+  "types": "./dist/types/htmlminifier.d.ts",
   "name": "html-minifier-next",
   "repository": "https://github.com/j9t/html-minifier-next.git",
   "scripts": {
-    "build": "rollup -c",
+    "prebuild": "node --eval='require(`fs`).rmSync(`dist`,{recursive:true,force:true})'",
+    "build": "tsc && rollup -c",
     "build:docs": "vite build --base /html-minifier-next/ --outDir build",
     "deploy": "npm run build && npm run build:docs",
     "lint": "eslint .",
     "prepack": "npm run build",
     "prepare": "git config core.hooksPath .githooks || true",
     "serve": "npm run build && vite",
-    "test": "node --test tests/*.spec.js",
+    "test": "npm run test:types && node --test tests/*.spec.js",
+    "test:types": "tsc --project tsconfig.test.json",
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "4.0.2"
+  "version": "4.1.1"
 }