Mht Delphi DLL Reference Documentation

Mht

Current Version: 11.5.0

Chilkat.Mht

Create, save, zip, email, and unpack MHT web archives.

Chilkat.Mht creates MHT web archives and EML email messages from HTTP/HTTPS pages, local HTML files, or in-memory HTML strings. It analyzes the supplied HTML source, resolves and retrieves supported static resources, rewrites references as needed, and packages the result as MIME. It also supports disk caching, proxies, authentication, file or ZIP output, and unpacking existing MHT data.

Create MHT archives

Convert a web page, local HTML file, or HTML string into an MHT archive with supported related resources embedded when settings permit and each resource can be obtained.

Generate EML messages

Produce an HTML-email MIME draft from HTML. Image embedding follows EmbedImages and EmbedLocalOnly; scripts, frames, and comments are removed. Addressing, subject, and sending remain application tasks.

Embed static resources

Capture images, CSS, CSS imports and backgrounds, and—when producing MHT—frames and supported external scripts.

Network configuration

Use proxy settings, authentication, caching, redirects, capture-scoped cookies, and related options when fetching pages and dependent resources.

Save or zip output

Return generated MHT or EML text in memory, save it to disk, or place it into a ZIP archive.

Unpack MHT files

Extract an MHT archive into an HTML file plus supporting resource files for inspection, editing, or republishing.

Not a browser rendering engine: Mht does not execute JavaScript, build or wait for a browser DOM, trigger lazy loading, or capture AJAX, fetch, XHR, React, Angular, Vue, or other client-rendered content. It captures the original HTML source and resources that are statically referenced by that source. MHT output can preserve scripts so they may execute when the saved archive is later opened; EML output always removes scripts.

URL or local file: Methods accepting a URL-or-file argument use a strict prefix rule. A value is a web URL only if it begins, case-insensitively, with http: or https:. Every other value is treated as a local path. file:// is not recognized. Relative paths use the process current working directory, and a local source file must already exist and be readable.

Base resolution: Resolution precedence is the HTML <base href> element, then BaseUrl, then the source page URL or local file directory. Use a URL—not a filesystem directory—for BaseUrl, and end a directory-style base URL with /. Downloaded CSS resolves its own relative url(...) and @import references against the stylesheet URL; inline CSS resolves against the page base.

Default static resource handling:

HTML/CSS reference	Behavior
`<img src>`	Captured by default, subject to `EmbedImages` and `EmbedLocalOnly`.
`srcset` / `sizes`	Not used for candidate selection. These attributes are stripped and the ordinary `src` is used; obvious spacer placeholders are detected so the real image can be captured.
CSS `url(...)`	Captured from external style sheets, `<style>` blocks, and inline `style` attributes.
CSS `@import`	Downloaded, inlined, and processed recursively.
`<link rel="stylesheet">`	Downloaded and inlined; its CSS references are then processed recursively.
`<iframe>` / `<frame>`	Fetched and captured for MHT; removed for EML.
`<script src>`	Supported external scripts are captured for MHT and inline scripts may be retained; all scripts are removed for EML. Script handling remains subject to `NoScripts` and `PreferMHTScripts`.
`<object data>`, `<embed src>`, media elements	References are made absolute, but the payload is not downloaded. This includes `video`, `audio`, `source`, and `track`.
Favicons	Not captured.
Navigation and form URLs	Made absolute when possible, but their targets are not downloaded.
HTTP redirects	Followed for the primary page and dependent resources. After a primary redirect, relative references use the final landing URL as their base.

Dependent-resource failures do not fail the capture: If a dependent image, style sheet, imported CSS file, frame, script, or other supported resource cannot be downloaded, Chilkat omits that MIME part, restores the HTML reference to the original absolute live URL, logs the problem in LastErrorText, and continues with a successful result. No empty placeholder part is created. Failure to load the primary URL or local HTML file does fail the operation. Consequently, output is fully self-contained only to the extent allowed by the embedding properties and the resources that were successfully obtained.

String-returning methods: For GetMHT, GetEML, HtmlToMHT, HtmlToEML, and GetCacheRoot, check LastMethodSuccess. Do not infer success or failure from whether the returned string is empty. On failure the string is cleared or may contain partial output, and LastErrorText contains the diagnostic.

File output: Save methods generate the MIME document in memory before opening the destination. Existing files are overwritten, parent directories are not created, and relative paths use the process current working directory. The final write is not atomic, so a write-time I/O failure can leave partial output. Generation failure leaves an existing destination file untouched.

Redirect and cookie behavior: Redirects are followed automatically for the main page and dependent resources. Cookies received during one capture are retained and sent on later requests in that same capture. The redirect limit, exact followed status codes, and HTTPS-to-HTTP downgrade policy are controlled by the underlying HTTP engine and are not exposed as Mht settings.

Object state persists: External style sheets, exclusion patterns, custom headers, and cache roots remain configured across conversions. RestoreDefaults clears only the external style-sheet and exclusion-pattern collections; it does not clear custom headers or cache roots. Cache roots can be reset only by using a new object.

Custom headers are cross-host: Permitted custom headers are sent to the primary page, redirect targets, and every dependent-resource host. Authorization and Content-Length are rejected, but other sensitive fields such as a manually supplied Cookie can be sent to third-party hosts.

MHT versus EML: Both are MIME documents with an HTML root and related embedded resources. MHT is a web-archive form and omits Date and X-Unsent. EML adds the current Date and X-Unsent: 1, removes scripts, frames, and comments, and is best treated as an HTML-email draft. It has no generated Message-ID and no plain-text alternative; the application must add the required addressing and subject information before sending.

Returned MIME strings: Preserve CRLF line endings and write the result as UTF-8 without a BOM. Treat the string as opaque MIME text. The file-writing methods are preferable when exact serialized bytes are required.

ZIP and unpack safety: ZIP methods reject an existing entry name and rewrite the complete archive non-atomically. Normal unpacking contains extracted paths beneath the requested directory, but existing files from earlier runs are overwritten. Direct unpack mode is for relative Content-Location values and skips parts whose locations are full URLs.

Common pattern: Provide an HTTP/HTTPS URL, a readable local HTML path, or an HTML string; configure the base URL, proxy, authentication, caching, and resource options; then return, save, or zip the MHT/EML output. When the desired content exists only after JavaScript executes, first obtain rendered HTML with a browser or browser-automation tool and pass that HTML to an HtmlTo* method.

For an extended overview, see Mht Class Overview.

Create/Dispose

var
myObject: HCkMht;

begin
myObject := CkMht_Create();

// ...

CkMht_Dispose(myObject);
end;

function CkMht_Create: HCkMht; stdcall;

Creates an instance of the HCkMht object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

procedure CkMht_Dispose(handle: HCkMht); stdcall;

Objects created by calling CkMht_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Properties

AbortCurrent

function CkMht_getAbortCurrent(objHandle: HCkMht): wordbool; stdcall;
procedure CkMht_putAbortCurrent(objHandle: HCkMht; newPropVal: wordbool); stdcall;

Introduced in version 9.5.0.58

Set to True to request cancellation of the operation currently running on this object. Long-running network and file operations periodically check this property; a fast operation may complete before the request is observed.

A synchronous method can be cancelled from another thread by setting this property on the same object. Chilkat resets the property to False after an abort is processed, and a stale request is cleared when a later method begins.

Cancellation request: Cancellation is cooperative rather than instantaneous. Always inspect the method's return value and diagnostic properties to determine the final outcome.

`EmbedImages`	`EmbedLocalOnly`	Image behavior
`False`	Either	No images are embedded. References are made absolute when sufficient base information is available.
`True`	`False`	Local and HTTP/HTTPS images are embedded when they can be obtained. This is the default combination.
`True`	`True`	Only local-file images are embedded. HTTP/HTTPS images remain external references.

Value	Behavior
`0`	Do not use a SOCKS proxy. This is the default.
`4`	Connect through a SOCKS4 proxy.
`5`	Connect through a SOCKS5 proxy.

Setting	Behavior
`False`	Normal mode: Chilkat selects the primary HTML part, writes related resources beneath the parts subdirectory, rewrites HTML references, and applies path-containment and filename-collision handling.
`True`	Direct mode: relative `Content-Location` paths are written beneath the unpack directory without the normal HTML-reference rewriting. The `partsSubDir` method argument is ignored.

Setting	Resource-part headers	HTML reference
`False`	A `Content-Location` containing the resolved URL or path; no `Content-ID`.	The resource is referenced by its URL or location.
`True`	A generated, angle-bracketed `Content-ID`; no `Content-Location`.	The resource URL is rewritten as `cid:<id>`.

`UseInline`	`UseFilename`	Generated `Content-Disposition`
`True`	`True`	`inline; filename="<name>"`
`True`	`False`	`inline`
`False`	`True`	`inline; filename="<name>"`
`False`	`False`	No `Content-Disposition` header.

Field name	Behavior when added again
`User-Agent` or `Accept-Language`	Replaces the existing value.
Any other permitted field	Appends another header line with the same name; it does not replace the earlier line.

Test	Matching rule
Wildcard / glob	Case-insensitive match against the entire resolved reference. `*` matches zero or more characters, and `?` matches exactly one character.
Plain substring	Case-sensitive containment test anywhere within the resolved reference.

Reset by this method	Result
`PreferMHTScripts`	Restored to `True`.
`EmbedImages`	Restored to `True`.
`EmbedLocalOnly`	Restored to `False`.
`NoScripts` and related internal script-removal state	Restored to the normal script-enabled MHT behavior.
External style sheets added by `AddExternalStyleSheet`	The entire list is cleared.
Exclusion patterns added by `ExcludeImagesMatching`	The entire list is cleared.

Mht Delphi DLL Reference Documentation

Mht

Current Version: 11.5.0

Create, save, zip, email, and unpack MHT web archives.

Create MHT archives

Generate EML messages

Embed static resources

Network configuration

Save or zip output

Unpack MHT files

Create/Dispose

Properties

AbortCurrent

BaseUrl

ConnectTimeout

DebugHtmlAfter

DebugHtmlBefore

DebugLogFilePath

EmbedImages

EmbedLocalOnly

FetchFromCache

HeartbeatMs

IgnoreMustRevalidate

IgnoreNoCache

LastErrorHtml

LastErrorText

LastErrorXml

LastMethodSuccess

NoScripts

NtlmAuth

NumCacheLevels

NumCacheRoots

PreferIpv6

PreferMHTScripts

Proxy

ProxyLogin

ProxyPassword

ReadTimeout

RequireSslCertVerify

SocksHostname

SocksPassword

SocksPort

SocksUsername

SocksVersion

UnpackDirect

UnpackUseRelPaths

UpdateCache

UseCids

UseFilename

UseIEProxy

UseInline

VerboseLogging

Version

WebSiteLogin

WebSiteLoginDomain

WebSitePassword

Methods

AddCacheRoot

AddCustomHeader

AddExternalStyleSheet

ClearCustomHeaders

ExcludeImagesMatching

GetAndSaveEML

GetAndSaveEMLAsync (1)

GetAndSaveMHT

GetAndSaveMHTAsync (1)

GetAndZipEML

GetAndZipEMLAsync (1)

GetAndZipMHT

GetAndZipMHTAsync (1)

GetCacheRoot

GetEML

GetEMLAsync (1)

GetMHT

GetMHTAsync (1)

HtmlToEML

HtmlToEMLAsync (1)

HtmlToEMLFile

HtmlToEMLFileAsync (1)

HtmlToMHT

GetAndSaveEMLAsync ⁽¹⁾

GetAndSaveMHTAsync ⁽¹⁾

GetAndZipEMLAsync ⁽¹⁾

GetAndZipMHTAsync ⁽¹⁾

GetEMLAsync ⁽¹⁾

GetMHTAsync ⁽¹⁾

HtmlToEMLAsync ⁽¹⁾

HtmlToEMLFileAsync ⁽¹⁾

HtmlToMHTAsync ⁽¹⁾

HtmlToMHTFileAsync ⁽¹⁾