---
product: Chilkat
product_version: 11.7.0
language: delphidll
language_label: Delphi DLL
class: StringBuilder
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/dd_CkStringBuilderRef.html
---
# Chilkat StringBuilder — Delphi DLL — v11.7.0

> Chilkat 11.7.0 · language=delphidll · class=StringBuilder
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/StringBuilder.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/guide.md`.

## Purpose

**Build, transform, search, encode, decode, hash, and save mutable text.**

`Chilkat.StringBuilder` is a flexible mutable text container for constructing and transforming strings. It supports appending text, integers, random values, UUIDs, encoded bytes, and `BinData`; searching, comparing, extracting, replacing, masking, regex processing, line-ending normalization, encoding, decoding, hashing, Markdown conversion, file I/O, and secure clearing of sensitive text.

**Build text incrementally**

Append strings, characters, integers, random values, UUIDs, encoded data, and other Chilkat objects without repeatedly recreating strings.

**Search and extract**

Find substrings, compare content, extract ranges, split or inspect text, and work with selected portions of the buffer.

**Replace and transform**

Replace text, mask sensitive values, normalize line endings, trim or edit content, and apply regex-based processing when needed.

**Encoding and decoding**

Encode or decode text and binary data using formats such as Base64, hex, URL encoding, quoted-printable, and other supported encodings.

**Hashing and conversion**

Compute hashes of the current text, convert Markdown to HTML, and move content between `StringBuilder`, `BinData`, files, and plain strings.

**File I/O and secure clearing**

Load text from files, save text with explicit character encodings, and securely clear the buffer when it contains sensitive data.

**Common pattern:** Use `StringBuilder` when text will be assembled or modified in multiple steps. Append or load the starting content, perform searches, replacements, encoding, decoding, hashing, or line-ending normalization, then retrieve the result as a string, save it to a file, or pass the object directly to another Chilkat method.

For an extended overview, see [StringBuilder Class Overview](https://www.chilkatsoft.com/stringbuilder_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```pascal
var
myObject: HCkStringBuilder;

begin
myObject := CkStringBuilder_Create();

// ...

CkStringBuilder_Dispose(myObject);
end;
```

`function CkStringBuilder_Create: HCkStringBuilder; stdcall;`

Creates an instance of the HCkStringBuilder 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 CkStringBuilder_Dispose(handle: HCkStringBuilder); stdcall;`

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

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Delphi DLL.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `procedure CkStringBuilder_getDebugLogFilePath(objHandle: HCkStringBuilder; outPropVal: HCkString); stdcall; procedure CkStringBuilder_putDebugLogFilePath(objHandle: HCkStringBuilder; newPropVal: PWideChar); stdcall; function CkStringBuilder__debugLogFilePath(objHandle: HCkStringBuilder): PWideChar; stdcall;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `procedure CkStringBuilder_getLastErrorHtml(objHandle: HCkStringBuilder; outPropVal: HCkString); stdcall; function CkStringBuilder__lastErrorHtml(objHandle: HCkStringBuilder): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `procedure CkStringBuilder_getLastErrorText(objHandle: HCkStringBuilder; outPropVal: HCkString); stdcall; function CkStringBuilder__lastErrorText(objHandle: HCkStringBuilder): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `procedure CkStringBuilder_getLastErrorXml(objHandle: HCkStringBuilder; outPropVal: HCkString); stdcall; function CkStringBuilder__lastErrorXml(objHandle: HCkStringBuilder): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `function CkStringBuilder_getLastMethodSuccess(objHandle: HCkStringBuilder): wordbool; stdcall; procedure CkStringBuilder_putLastMethodSuccess(objHandle: HCkStringBuilder; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `function CkStringBuilder_getVerboseLogging(objHandle: HCkStringBuilder): wordbool; stdcall; procedure CkStringBuilder_putVerboseLogging(objHandle: HCkStringBuilder; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `procedure CkStringBuilder_getVersion(objHandle: HCkStringBuilder; outPropVal: HCkString); stdcall; function CkStringBuilder__version(objHandle: HCkStringBuilder): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `HasEmojis` | property, read-only | `function CkStringBuilder_getHasEmojis(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `IntValue` | property, read/write | `function CkStringBuilder_getIntValue(objHandle: HCkStringBuilder): Integer; stdcall; procedure CkStringBuilder_putIntValue(objHandle: HCkStringBuilder; newPropVal: Integer); stdcall;` |
| `IsBase64` | property, read-only | `function CkStringBuilder_getIsBase64(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `Length` | property, read-only | `function CkStringBuilder_getLength(objHandle: HCkStringBuilder): Integer; stdcall;` |
| `Append` | method | `function CkStringBuilder_Append(objHandle: HCkStringBuilder;     value: PWideChar): wordbool; stdcall;` |
| `AppendBd` | method | `function CkStringBuilder_AppendBd(objHandle: HCkStringBuilder;     binData: HCkBinData;     charset: PWideChar;     offset: Integer;     numBytes: Integer): wordbool; stdcall;` |
| `AppendInt` | method | `function CkStringBuilder_AppendInt(objHandle: HCkStringBuilder;     value: Integer): wordbool; stdcall;` |
| `AppendInt64` | method | `function CkStringBuilder_AppendInt64(objHandle: HCkStringBuilder;     value: Int64): wordbool; stdcall;` |
| `AppendLine` | method | `function CkStringBuilder_AppendLine(objHandle: HCkStringBuilder;     str: PWideChar;     crlf: wordbool): wordbool; stdcall;` |
| `AppendLn` | method | `function CkStringBuilder_AppendLn(objHandle: HCkStringBuilder;     str: PWideChar): wordbool; stdcall;` |
| `AppendRandom` | method | `function CkStringBuilder_AppendRandom(objHandle: HCkStringBuilder;     numBytes: Integer;     encoding: PWideChar): wordbool; stdcall;` |
| `AppendSb` | method | `function CkStringBuilder_AppendSb(objHandle: HCkStringBuilder;     sb: HCkStringBuilder): wordbool; stdcall;` |
| `AppendUuid` | method | `function CkStringBuilder_AppendUuid(objHandle: HCkStringBuilder;     lowerCase: wordbool): wordbool; stdcall;` |
| `AppendUuid7` | method | `function CkStringBuilder_AppendUuid7(objHandle: HCkStringBuilder;     lowerCase: wordbool): wordbool; stdcall;` |
| `Clear` | method | `procedure CkStringBuilder_Clear(objHandle: HCkStringBuilder) stdcall;` |
| `Contains` | method | `function CkStringBuilder_Contains(objHandle: HCkStringBuilder;     str: PWideChar;     caseSensitive: wordbool): wordbool; stdcall;` |
| `ContainsWord` | method | `function CkStringBuilder_ContainsWord(objHandle: HCkStringBuilder;     word: PWideChar;     caseSensitive: wordbool): wordbool; stdcall;` |
| `ContentsEqual` | method | `function CkStringBuilder_ContentsEqual(objHandle: HCkStringBuilder;     str: PWideChar;     caseSensitive: wordbool): wordbool; stdcall;` |
| `ContentsEqualSb` | method | `function CkStringBuilder_ContentsEqualSb(objHandle: HCkStringBuilder;     sb: HCkStringBuilder;     caseSensitive: wordbool): wordbool; stdcall;` |
| `Decode` | method | `function CkStringBuilder_Decode(objHandle: HCkStringBuilder;     encoding: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `DecodeAndAppend` | method | `function CkStringBuilder_DecodeAndAppend(objHandle: HCkStringBuilder;     value: PWideChar;     encoding: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `Encode` | method | `function CkStringBuilder_Encode(objHandle: HCkStringBuilder;     encoding: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `EndsWith` | method | `function CkStringBuilder_EndsWith(objHandle: HCkStringBuilder;     substr: PWideChar;     caseSensitive: wordbool): wordbool; stdcall;` |
| `EntityDecode` | method | `function CkStringBuilder_EntityDecode(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `GetAfterBetween` | method | `function CkStringBuilder_GetAfterBetween(objHandle: HCkStringBuilder;     searchAfter: PWideChar;     beginMark: PWideChar;     endMark: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getAfterBetween(objHandle: HCkStringBuilder;     searchAfter: PWideChar;     beginMark: PWideChar;     endMark: PWideChar): PWideChar; stdcall;` |
| `GetAfterFinal` | method | `function CkStringBuilder_GetAfterFinal(objHandle: HCkStringBuilder;     marker: PWideChar;     removeFlag: wordbool;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getAfterFinal(objHandle: HCkStringBuilder;     marker: PWideChar;     removeFlag: wordbool): PWideChar; stdcall;` |
| `GetAsString` | method | `function CkStringBuilder_GetAsString(objHandle: HCkStringBuilder;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getAsString(objHandle: HCkStringBuilder): PWideChar; stdcall;` |
| `GetBefore` | method | `function CkStringBuilder_GetBefore(objHandle: HCkStringBuilder;     marker: PWideChar;     removeFlag: wordbool;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getBefore(objHandle: HCkStringBuilder;     marker: PWideChar;     removeFlag: wordbool): PWideChar; stdcall;` |
| `GetBetween` | method | `function CkStringBuilder_GetBetween(objHandle: HCkStringBuilder;     beginMark: PWideChar;     endMark: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getBetween(objHandle: HCkStringBuilder;     beginMark: PWideChar;     endMark: PWideChar): PWideChar; stdcall;` |
| `GetEncoded` | method | `function CkStringBuilder_GetEncoded(objHandle: HCkStringBuilder;     encoding: PWideChar;     charset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getEncoded(objHandle: HCkStringBuilder;     encoding: PWideChar;     charset: PWideChar): PWideChar; stdcall;` |
| `GetHash` | method | `function CkStringBuilder_GetHash(objHandle: HCkStringBuilder;     algorithm: PWideChar;     encoding: PWideChar;     charset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getHash(objHandle: HCkStringBuilder;     algorithm: PWideChar;     encoding: PWideChar;     charset: PWideChar): PWideChar; stdcall;` |
| `GetNth` | method | `function CkStringBuilder_GetNth(objHandle: HCkStringBuilder;     index: Integer;     delimiterChar: PWideChar;     exceptDoubleQuoted: wordbool;     exceptEscaped: wordbool;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getNth(objHandle: HCkStringBuilder;     index: Integer;     delimiterChar: PWideChar;     exceptDoubleQuoted: wordbool;     exceptEscaped: wordbool): PWideChar; stdcall;` |
| `GetRange` | method | `function CkStringBuilder_GetRange(objHandle: HCkStringBuilder;     startIndex: Integer;     numChars: Integer;     removeFlag: wordbool;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__getRange(objHandle: HCkStringBuilder;     startIndex: Integer;     numChars: Integer;     removeFlag: wordbool): PWideChar; stdcall;` |
| `GetRangeSb` | method | `function CkStringBuilder_GetRangeSb(objHandle: HCkStringBuilder;     startIndex: Integer;     numChars: Integer;     removeFlag: wordbool;     sb: HCkStringBuilder): wordbool; stdcall;` |
| `HtmlToMarkdown` | method | `function CkStringBuilder_HtmlToMarkdown(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `IsWellFormed` | method | `function CkStringBuilder_IsWellFormed(objHandle: HCkStringBuilder;     format: PWideChar): wordbool; stdcall;` |
| `LastNLines` | method | `function CkStringBuilder_LastNLines(objHandle: HCkStringBuilder;     numLines: Integer;     bCrlf: wordbool;     outStr: HCkString): wordbool; stdcall; function CkStringBuilder__lastNLines(objHandle: HCkStringBuilder;     numLines: Integer;     bCrlf: wordbool): PWideChar; stdcall;` |
| `LoadFile` | method | `function CkStringBuilder_LoadFile(objHandle: HCkStringBuilder;     path: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `MarkdownToHtml` | method | `function CkStringBuilder_MarkdownToHtml(objHandle: HCkStringBuilder;     options: HCkJsonObject;     sbHtml: HCkStringBuilder): wordbool; stdcall;` |
| `MaskQuotedStrings` | method | `function CkStringBuilder_MaskQuotedStrings(objHandle: HCkStringBuilder;     maskChar: PWideChar;     quoteType: Integer;     maskedStrings: HCkStringTable): wordbool; stdcall;` |
| `Obfuscate` | method | `procedure CkStringBuilder_Obfuscate(objHandle: HCkStringBuilder) stdcall;` |
| `Prepend` | method | `function CkStringBuilder_Prepend(objHandle: HCkStringBuilder;     value: PWideChar): wordbool; stdcall;` |
| `PunyDecode` | method | `function CkStringBuilder_PunyDecode(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `PunyEncode` | method | `function CkStringBuilder_PunyEncode(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `RegexMatch` | method | `function CkStringBuilder_RegexMatch(objHandle: HCkStringBuilder;     pattern: PWideChar;     json: HCkJsonObject;     timeoutMs: Integer): Integer; stdcall;` |
| `RegexReplace` | method | `function CkStringBuilder_RegexReplace(objHandle: HCkStringBuilder;     json: HCkJsonObject): wordbool; stdcall;` |
| `RemoveAccents` | method | `function CkStringBuilder_RemoveAccents(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `RemoveAfterFinal` | method | `function CkStringBuilder_RemoveAfterFinal(objHandle: HCkStringBuilder;     marker: PWideChar): wordbool; stdcall;` |
| `RemoveBefore` | method | `function CkStringBuilder_RemoveBefore(objHandle: HCkStringBuilder;     marker: PWideChar): wordbool; stdcall;` |
| `RemoveCharsAt` | method | `function CkStringBuilder_RemoveCharsAt(objHandle: HCkStringBuilder;     startIndex: Integer;     numChars: Integer): wordbool; stdcall;` |
| `RemoveEmojis` | method | `procedure CkStringBuilder_RemoveEmojis(objHandle: HCkStringBuilder) stdcall;` |
| `Replace` | method | `function CkStringBuilder_Replace(objHandle: HCkStringBuilder;     value: PWideChar;     replacement: PWideChar): Integer; stdcall;` |
| `ReplaceAfterFinal` | method | `function CkStringBuilder_ReplaceAfterFinal(objHandle: HCkStringBuilder;     marker: PWideChar;     replacement: PWideChar): wordbool; stdcall;` |
| `ReplaceAllBetween` | method | `function CkStringBuilder_ReplaceAllBetween(objHandle: HCkStringBuilder;     beginMark: PWideChar;     endMark: PWideChar;     replacement: PWideChar;     replaceMarks: wordbool): wordbool; stdcall;` |
| `ReplaceBetween` | method | `function CkStringBuilder_ReplaceBetween(objHandle: HCkStringBuilder;     beginMark: PWideChar;     endMark: PWideChar;     value: PWideChar;     replacement: PWideChar): Integer; stdcall;` |
| `ReplaceFirst` | method | `function CkStringBuilder_ReplaceFirst(objHandle: HCkStringBuilder;     value: PWideChar;     replacement: PWideChar): wordbool; stdcall;` |
| `ReplaceI` | method | `function CkStringBuilder_ReplaceI(objHandle: HCkStringBuilder;     value: PWideChar;     replacement: Integer): Integer; stdcall;` |
| `ReplaceNoCase` | method | `function CkStringBuilder_ReplaceNoCase(objHandle: HCkStringBuilder;     value: PWideChar;     replacement: PWideChar): Integer; stdcall;` |
| `ReplaceWord` | method | `function CkStringBuilder_ReplaceWord(objHandle: HCkStringBuilder;     value: PWideChar;     replacement: PWideChar): Integer; stdcall;` |
| `RestoreMaskedStrings` | method | `function CkStringBuilder_RestoreMaskedStrings(objHandle: HCkStringBuilder;     quoteType: Integer;     maskedStrings: HCkStringTable): wordbool; stdcall;` |
| `SecureClear` | method | `procedure CkStringBuilder_SecureClear(objHandle: HCkStringBuilder) stdcall;` |
| `SetNth` | method | `function CkStringBuilder_SetNth(objHandle: HCkStringBuilder;     index: Integer;     value: PWideChar;     delimiterChar: PWideChar;     exceptDoubleQuoted: wordbool;     exceptEscaped: wordbool): wordbool; stdcall;` |
| `SetString` | method | `function CkStringBuilder_SetString(objHandle: HCkStringBuilder;     value: PWideChar): wordbool; stdcall;` |
| `Shorten` | method | `function CkStringBuilder_Shorten(objHandle: HCkStringBuilder;     numChars: Integer): wordbool; stdcall;` |
| `StartsWith` | method | `function CkStringBuilder_StartsWith(objHandle: HCkStringBuilder;     substr: PWideChar;     caseSensitive: wordbool): wordbool; stdcall;` |
| `ToCRLF` | method | `function CkStringBuilder_ToCRLF(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `ToLF` | method | `function CkStringBuilder_ToLF(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `ToLowercase` | method | `function CkStringBuilder_ToLowercase(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `ToUppercase` | method | `function CkStringBuilder_ToUppercase(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `Trim` | method | `function CkStringBuilder_Trim(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `TrimInsideSpaces` | method | `function CkStringBuilder_TrimInsideSpaces(objHandle: HCkStringBuilder): wordbool; stdcall;` |
| `Unobfuscate` | method | `procedure CkStringBuilder_Unobfuscate(objHandle: HCkStringBuilder) stdcall;` |
| `WriteFile` | method | `function CkStringBuilder_WriteFile(objHandle: HCkStringBuilder;     path: PWideChar;     charset: PWideChar;     emitBom: wordbool): wordbool; stdcall;` |
| `WriteFileIfModified` | method | `function CkStringBuilder_WriteFileIfModified(objHandle: HCkStringBuilder;     path: PWideChar;     charset: PWideChar;     emitBom: wordbool): wordbool; stdcall;` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### StringBuilder.HasEmojis

`Chilkat 11.7.0 · delphidll · StringBuilder · HasEmojis · property · read-only · since 11.1.0`

```pascal
function CkStringBuilder_getHasEmojis(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Returns `True` if the content contains one or more emoji characters.

### StringBuilder.IntValue

`Chilkat 11.7.0 · delphidll · StringBuilder · IntValue · property · read/write · since 9.5.0.58`

```pascal
function CkStringBuilder_getIntValue(objHandle: HCkStringBuilder): Integer; stdcall;
procedure CkStringBuilder_putIntValue(objHandle: HCkStringBuilder; newPropVal: Integer); stdcall;
```

Returns the content of the string converted to an integer.

### StringBuilder.IsBase64

`Chilkat 11.7.0 · delphidll · StringBuilder · IsBase64 · property · read-only · since 9.5.0.76`

```pascal
function CkStringBuilder_getIsBase64(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Returns `True` if the content contains only those characters allowed in the base64 encoding. A base64 string is composed of characters 'A'..'Z', 'a'..'z', '0'..'9', '+', '/' and it is often padded at the end with up to two '=', to make the length a multiple of 4. Whitespace is ignored.

### StringBuilder.Length

`Chilkat 11.7.0 · delphidll · StringBuilder · Length · property · read-only · since 9.5.0.58`

```pascal
function CkStringBuilder_getLength(objHandle: HCkStringBuilder): Integer; stdcall;
```

The number of characters of the string contained within this instance.

## Methods

### StringBuilder.Append

`Chilkat 11.7.0 · delphidll · StringBuilder · Append · method · since 9.5.0.58`

```pascal
function CkStringBuilder_Append(objHandle: HCkStringBuilder;
    value: PWideChar): wordbool; stdcall;
```

Appends a copy of the specified string to this instance.

Returns True for success, False for failure.

### StringBuilder.AppendBd

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendBd · method · since 9.5.0.64`

```pascal
function CkStringBuilder_AppendBd(objHandle: HCkStringBuilder;
    binData: HCkBinData;
    charset: PWideChar;
    offset: Integer;
    numBytes: Integer): wordbool; stdcall;
```

Appends the contents of `binData`. The `charset` specifies the character encoding of the bytes contained in `binData`. The `charset` can be any of the supported encodings listed at [Chilkat Supported Character Encodings](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp). To append the entire contents of `binData`, set `offset` and `numBytes` equal to zero. To append a range of `binData`, set the `offset` and `numBytes` to specify the range.

Returns True for success, False for failure.

### StringBuilder.AppendInt

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendInt · method · since 9.5.0.58`

```pascal
function CkStringBuilder_AppendInt(objHandle: HCkStringBuilder;
    value: Integer): wordbool; stdcall;
```

Appends the string representation of a specified 32-bit signed integer to this instance.

Returns True for success, False for failure.

### StringBuilder.AppendInt64

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendInt64 · method · since 9.5.0.58`

```pascal
function CkStringBuilder_AppendInt64(objHandle: HCkStringBuilder;
    value: Int64): wordbool; stdcall;
```

Appends the string representation of a specified 64-bit signed integer to this instance.

Returns True for success, False for failure.

### StringBuilder.AppendLine

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendLine · method · since 9.5.0.65`

```pascal
function CkStringBuilder_AppendLine(objHandle: HCkStringBuilder;
    str: PWideChar;
    crlf: wordbool): wordbool; stdcall;
```

Appends the `str` followed by a CRLF or LF to the end of the curent StringBuilder object. If `crlf` is `True`, then a CRLF line ending is used. Otherwise a LF line ending is used.

Returns True for success, False for failure.

### StringBuilder.AppendLn

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendLn · method · since 11.5.0`

```pascal
function CkStringBuilder_AppendLn(objHandle: HCkStringBuilder;
    str: PWideChar): wordbool; stdcall;
```

Appends the `str` followed by a CRLF to the end of this object. This method is the same as `AppendLine` , except the line-ending is always CRLF.

Returns True for success, False for failure.

### StringBuilder.AppendRandom

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendRandom · method · since 9.5.0.96`

```pascal
function CkStringBuilder_AppendRandom(objHandle: HCkStringBuilder;
    numBytes: Integer;
    encoding: PWideChar): wordbool; stdcall;
```

Append `numBytes` random bytes encoded according to `encoding`. `encoding` can be `hex`, `hex_lower`, `base64`, `base64url`, or any other encoding supported by Chilkat.

Returns True for success, False for failure.

### StringBuilder.AppendSb

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendSb · method · since 9.5.0.62`

```pascal
function CkStringBuilder_AppendSb(objHandle: HCkStringBuilder;
    sb: HCkStringBuilder): wordbool; stdcall;
```

Appends the contents of another StringBuilder to this instance.

Returns True for success, False for failure.

### StringBuilder.AppendUuid

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendUuid · method · since 9.5.0.93`

```pascal
function CkStringBuilder_AppendUuid(objHandle: HCkStringBuilder;
    lowerCase: wordbool): wordbool; stdcall;
```

Generates and appends a random GUID/UUID such as 63c35f38-2b5f-4600-b3da-3ddee86d62b3. If `lowerCase` is `True`, then the hex values use lowercase (`a` - `f`). If `lowerCase` is `False` then uppercase is used (`A` - `F`).

Note: This generates a version 4 UUID.

Returns True for success, False for failure.

### StringBuilder.AppendUuid7

`Chilkat 11.7.0 · delphidll · StringBuilder · AppendUuid7 · method · since 10.1.0`

```pascal
function CkStringBuilder_AppendUuid7(objHandle: HCkStringBuilder;
    lowerCase: wordbool): wordbool; stdcall;
```

Generates and appends a random version 7 UUID. If `lowerCase` is `True`, then the hex values use lowercase (`a` - `f`). If `lowerCase` is `False` then uppercase is used (`A` - `F`).

Returns True for success, False for failure.

### StringBuilder.Clear

`Chilkat 11.7.0 · delphidll · StringBuilder · Clear · method · since 9.5.0.58`

```pascal
procedure CkStringBuilder_Clear(objHandle: HCkStringBuilder) stdcall;
```

Removes all characters from the current StringBuilder instance.

### StringBuilder.Contains

`Chilkat 11.7.0 · delphidll · StringBuilder · Contains · method · since 9.5.0.58`

```pascal
function CkStringBuilder_Contains(objHandle: HCkStringBuilder;
    str: PWideChar;
    caseSensitive: wordbool): wordbool; stdcall;
```

Returns `True` if the `str` is contained within this object. For case sensitive matching, set `caseSensitive` equal to `True`. For case-insensitive, set `caseSensitive` equal to `False`.

### StringBuilder.ContainsWord

`Chilkat 11.7.0 · delphidll · StringBuilder · ContainsWord · method · since 9.5.0.69`

```pascal
function CkStringBuilder_ContainsWord(objHandle: HCkStringBuilder;
    word: PWideChar;
    caseSensitive: wordbool): wordbool; stdcall;
```

Returns `True` if the `word` is contained within this object, but only if it is a whole word. This method is limited to finding whole words in strings that only contains characters in the Latin1 charset (i.e. iso-8859-1 or Windows-1252). A whole word can only contain alphanumeric chars where the alpha chars are restricted to those of the Latin1 alpha chars. (The underscore character is also considered part of a word.)

For case sensitive matching, set `caseSensitive` equal to `True`. For case-insensitive, set `caseSensitive` equal to `False`.

### StringBuilder.ContentsEqual

`Chilkat 11.7.0 · delphidll · StringBuilder · ContentsEqual · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ContentsEqual(objHandle: HCkStringBuilder;
    str: PWideChar;
    caseSensitive: wordbool): wordbool; stdcall;
```

Returns `True` if the contents of this object equals the `str`. Returns `False` if unequal. For case insensitive equality, set `caseSensitive` equal to `False`.

### StringBuilder.ContentsEqualSb

`Chilkat 11.7.0 · delphidll · StringBuilder · ContentsEqualSb · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ContentsEqualSb(objHandle: HCkStringBuilder;
    sb: HCkStringBuilder;
    caseSensitive: wordbool): wordbool; stdcall;
```

Returns `True` if the contents of this object equals the `sb`. Returns `False` if unequal. For case insensitive equality, set `caseSensitive` equal to `False`.

### StringBuilder.Decode

`Chilkat 11.7.0 · delphidll · StringBuilder · Decode · method · since 9.5.0.62`

```pascal
function CkStringBuilder_Decode(objHandle: HCkStringBuilder;
    encoding: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Decodes and replaces the contents with the decoded string. The `encoding` can be set to any of the following strings: `base64`, `hex`, `quoted-printable` (or `qp`), `url`, `base32`, `Q`, `B`, `url_rc1738`, `url_rfc2396`, `url_rfc3986`, `url_oauth`, `uu`, `modBase64`, or `html` (for HTML entity encoding). The full up-to-date list of supported binary encodings is available at the link entitled `Supported Binary Encodings` below.

Note: This method can only be called if the encoded content decodes to a string. The `charset` indicates the charset to be used in intepreting the decoded bytes. For example, the `charset` can be `utf-8`, `utf-16`, `iso-8859-1`, `shift_JIS`, etc.

Returns True for success, False for failure.

### StringBuilder.DecodeAndAppend

`Chilkat 11.7.0 · delphidll · StringBuilder · DecodeAndAppend · method · since 9.5.0.87`

```pascal
function CkStringBuilder_DecodeAndAppend(objHandle: HCkStringBuilder;
    value: PWideChar;
    encoding: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Decodes a binary encoded string, where the binary encoding (such as `url`, `hex`, `base64`, etc.) is specified by `encoding`, and the underlying charset encoding (such as `utf-8`, `windows-1252`, etc.) is specified by `charset`. The decoded string is appended to this object.

Returns True for success, False for failure.

### StringBuilder.Encode

`Chilkat 11.7.0 · delphidll · StringBuilder · Encode · method · since 9.5.0.62`

```pascal
function CkStringBuilder_Encode(objHandle: HCkStringBuilder;
    encoding: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Encodes to base64, hex, quoted-printable, URL encoding, etc. The `encoding` can be set to any of the following strings: `base64`, `hex`, `quoted-printable` (or `qp`), `url`, `base32`, `Q`, `B`, `url_rc1738`, `url_rfc2396`, `url_rfc3986`, `url_oauth`, `uu`, `modBase64`, or `html` (for HTML entity encoding). The full up-to-date list of supported binary encodings is available at the link entitled `Supported Binary Encodings` below.

Returns True for success, False for failure.

### StringBuilder.EndsWith

`Chilkat 11.7.0 · delphidll · StringBuilder · EndsWith · method · since 9.5.0.62`

```pascal
function CkStringBuilder_EndsWith(objHandle: HCkStringBuilder;
    substr: PWideChar;
    caseSensitive: wordbool): wordbool; stdcall;
```

Returns `True` if the string ends with `substr`. Otherwise returns `False`. The comparison is case sensitive if `caseSensitive` is `True`, and case insensitive if `caseSensitive` is `False`.

### StringBuilder.EntityDecode

`Chilkat 11.7.0 · delphidll · StringBuilder · EntityDecode · method · since 9.5.0.62`

```pascal
function CkStringBuilder_EntityDecode(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Decodes HTML entities. See [HTML entities](https://duckduckgo.com/?q=html+entities&bext=wfp&ia=web) for more information about HTML entities.

Returns True for success, False for failure.

### StringBuilder.GetAfterBetween

`Chilkat 11.7.0 · delphidll · StringBuilder · GetAfterBetween · method · since 9.5.0.62`

```pascal
function CkStringBuilder_GetAfterBetween(objHandle: HCkStringBuilder;
    searchAfter: PWideChar;
    beginMark: PWideChar;
    endMark: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getAfterBetween(objHandle: HCkStringBuilder;
    searchAfter: PWideChar;
    beginMark: PWideChar;
    endMark: PWideChar): PWideChar; stdcall;
```

Begin searching after the 1st occurrence of `searchAfter` is found, and then return the substring found between the next occurrence of `beginMark` and the next occurrence of `endMark`.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetAfterFinal

`Chilkat 11.7.0 · delphidll · StringBuilder · GetAfterFinal · method · since 9.5.0.77`

```pascal
function CkStringBuilder_GetAfterFinal(objHandle: HCkStringBuilder;
    marker: PWideChar;
    removeFlag: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getAfterFinal(objHandle: HCkStringBuilder;
    marker: PWideChar;
    removeFlag: wordbool): PWideChar; stdcall;
```

Returns the substring found after the final occurrence of `marker`. If `removeFlag` is `True`, the `marker` and the content that follows is removed from this content.

If the `marker` is not present, then the entire string is returned. In this case, if `removeFlag` is `True`, this object is also cleared.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetAsString

`Chilkat 11.7.0 · delphidll · StringBuilder · GetAsString · method · since 9.5.0.58`

```pascal
function CkStringBuilder_GetAsString(objHandle: HCkStringBuilder;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getAsString(objHandle: HCkStringBuilder): PWideChar; stdcall;
```

Returns the contents as a string.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetBefore

`Chilkat 11.7.0 · delphidll · StringBuilder · GetBefore · method · since 9.5.0.77`

```pascal
function CkStringBuilder_GetBefore(objHandle: HCkStringBuilder;
    marker: PWideChar;
    removeFlag: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getBefore(objHandle: HCkStringBuilder;
    marker: PWideChar;
    removeFlag: wordbool): PWideChar; stdcall;
```

Returns the substring found before the 1st occurrence of `marker`. If `removeFlag` is `True`, the content up to and including the `marker` is removed from this object's contents.

If the `marker` is not present, then the entire string is returned. In this case, if `removeFlag` is `True`, this object is also cleared.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetBetween

`Chilkat 11.7.0 · delphidll · StringBuilder · GetBetween · method · since 9.5.0.62`

```pascal
function CkStringBuilder_GetBetween(objHandle: HCkStringBuilder;
    beginMark: PWideChar;
    endMark: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getBetween(objHandle: HCkStringBuilder;
    beginMark: PWideChar;
    endMark: PWideChar): PWideChar; stdcall;
```

Returns the substring found between the 1st occurrence of `beginMark` and the next occurrence of `endMark`.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetEncoded

`Chilkat 11.7.0 · delphidll · StringBuilder · GetEncoded · method · since 9.5.0.62`

```pascal
function CkStringBuilder_GetEncoded(objHandle: HCkStringBuilder;
    encoding: PWideChar;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getEncoded(objHandle: HCkStringBuilder;
    encoding: PWideChar;
    charset: PWideChar): PWideChar; stdcall;
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Returns the string contents encoded in an encoding such as base64, hex, quoted-printable, or URL-encoding. The `encoding` can be set to any of the following strings: `base64`, `hex`, `quoted-printable` (or `qp`), `url`, `base32`, `Q`, `B`, `url_rc1738`, `url_rfc2396`, `url_rfc3986`, `url_oauth`, `uu`, `modBase64`, or `html` (for HTML entity encoding). The full up-to-date list of supported binary encodings is available at the link entitled `Supported Binary Encodings` below.

Note: The Encode method modifies the content of this object. The GetEncoded method leaves this object's content unmodified.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetHash

`Chilkat 11.7.0 · delphidll · StringBuilder · GetHash · method · since 9.5.0.91`

```pascal
function CkStringBuilder_GetHash(objHandle: HCkStringBuilder;
    algorithm: PWideChar;
    encoding: PWideChar;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getHash(objHandle: HCkStringBuilder;
    algorithm: PWideChar;
    encoding: PWideChar;
    charset: PWideChar): PWideChar; stdcall;
```

Returns the hash of the contents of this object. The `algorithm` is the hash algorithm, and can be `sha1`, `sha256`, `sha384`, `sha512`, `sha3-224`, `sha3-256`, `sha3-384`, `sha3-512`, `md2`, `md5`, `ripemd128`, `ripemd160`,`ripemd256`, or `ripemd320`. The `encoding` can be `base64`, `modBase64`, `base64Url`, `base32`, `base58`, `qp` (for quoted-printable), `url` (for url-encoding), `hex`, `hexLower`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

The `charset` is the character encoding byte representation to hash. It is typically `utf-8`. It can be any of the chacter encodings listed at [Chilkat Character Encodings List](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetNth

`Chilkat 11.7.0 · delphidll · StringBuilder · GetNth · method · since 9.5.0.62`

```pascal
function CkStringBuilder_GetNth(objHandle: HCkStringBuilder;
    index: Integer;
    delimiterChar: PWideChar;
    exceptDoubleQuoted: wordbool;
    exceptEscaped: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getNth(objHandle: HCkStringBuilder;
    index: Integer;
    delimiterChar: PWideChar;
    exceptDoubleQuoted: wordbool;
    exceptEscaped: wordbool): PWideChar; stdcall;
```

Returns the Nth substring in string that is a list delimted by `delimiterChar`. The first substring is at index 0. If `exceptDoubleQuoted` is `True`, then the delimiter char found between double quotes is not treated as a delimiter. If `exceptEscaped` is `True`, then an escaped (with a backslash) delimiter char is not treated as a delimiter.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetRange

`Chilkat 11.7.0 · delphidll · StringBuilder · GetRange · method · since 9.5.0.87`

```pascal
function CkStringBuilder_GetRange(objHandle: HCkStringBuilder;
    startIndex: Integer;
    numChars: Integer;
    removeFlag: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__getRange(objHandle: HCkStringBuilder;
    startIndex: Integer;
    numChars: Integer;
    removeFlag: wordbool): PWideChar; stdcall;
```

Returns a string containing the specified range of characters from this instance. If `removeFlag` is `True`, then the range of chars is removed from this instance.

Note: It was discovered that the range of chars was always removed regardless of the value of `removeFlag`. This is fixed in v9.5.0.89.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.GetRangeSb

`Chilkat 11.7.0 · delphidll · StringBuilder · GetRangeSb · method · since 11.3.0`

```pascal
function CkStringBuilder_GetRangeSb(objHandle: HCkStringBuilder;
    startIndex: Integer;
    numChars: Integer;
    removeFlag: wordbool;
    sb: HCkStringBuilder): wordbool; stdcall;
```

Appends to `startIndex` the specified range of characters from this instance. If `removeFlag` is `True`, then the range of chars is removed from this instance.

Returns True for success, False for failure.

### StringBuilder.HtmlToMarkdown

`Chilkat 11.7.0 · delphidll · StringBuilder · HtmlToMarkdown · method · since 11.7.0`

```pascal
function CkStringBuilder_HtmlToMarkdown(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Converts the HTML contained in this object to Markdown, replacing the contents with the Markdown. Returns `True` on success. If the conversion fails, the contents are left unchanged and the reason is in the LastErrorText.

This is the reverse of `MarkdownToHtml`. The HTML is parsed with the same parser used by `Html.ToXml` and `Html.ToText`, and the resulting document tree produces CommonMark / GitHub-flavored Markdown:

- `h1` through `h6` become `#` .. `######` headings.
- `p`, `div`, `section` and other block-level elements become paragraphs separated by a blank line. `br` becomes a hard line break and `hr` becomes `---`.
- `b`/`strong` become `**bold**`, `i`/`em`/`cite` become `*italic*`, `del`/`s`/`strike` become `~~struck~~`, and `code`/`kbd`/`samp` become a backtick code span.
- `pre` becomes a fenced code block. The language is taken from a `language-xxx` or `lang-xxx` class on the `pre` or its `code` child.
- `a href` becomes `[text](url "title")`, and `img` becomes `![alt](src "title")`.
- `ul`/`ol`/`li` become `-` and `1.` lists, with nested lists indented. A checkbox `input` inside a list item becomes `[ ]` or `[x]`.
- `blockquote` becomes lines prefixed with `>`.
- `table` becomes a GitHub pipe table. The first row is the header when it contains `th` cells or is inside a `thead`; `colspan` is honored, and `align` or `text-align` sets the column alignment. A single-column table becomes plain paragraphs, because such tables are usually for layout.
- `dl`/`dt`/`dd` become a term line followed by `: definition` lines.

`head`, `script`, `style`, `title`, `meta`, `link`, `noscript`, `iframe`, `object`, `embed`, `svg`, `canvas`, form controls and comments produce no output. Any other tag is transparent: only its content is emitted.

Markdown-significant punctuation in ordinary text is backslash-escaped so that the text renders literally. Text inside `code` and `pre` is never escaped. HTML entities are decoded.

The Markdown uses LF line endings, always ends with a single line ending, and never contains more than one consecutive blank line outside of a code block. Call `ToCRLF` afterwards for CRLF line endings.

**Note:** The conversion is in-place. The HTML is not available after a successful call, so load it into a separate `StringBuilder` first if it is still needed.

Empty contents, or HTML with no visible content, produce empty contents and `True` is returned.

Returns True for success, False for failure.

### StringBuilder.IsWellFormed

`Chilkat 11.7.0 · delphidll · StringBuilder · IsWellFormed · method · since 11.6.0`

```pascal
function CkStringBuilder_IsWellFormed(objHandle: HCkStringBuilder;
    format: PWideChar): wordbool; stdcall;
```

Returns `True` if the contents of this object are well-formed JSON or XML. `format` selects which check to apply and must be `json` or `xml` (case insensitive). Returns `False` if the contents do not conform, or if `format` is anything else.

Chilkat's JSON and XML parsers are deliberately tolerant. Given text that is not well-formed they can still report success, leaving an empty or partially populated document. This method answers the question those parsers do not, and it does so without loading the text into a `JsonObject` or `Xml` object first. The checks applied here are the same ones those classes apply when their `Strict` property is set.

For `xml` this is a **well-formedness** check: element nesting and tag matching, attribute syntax and duplicate attributes, entity and character references, comments, processing instructions, CDATA sections, the XML declaration, the DOCTYPE declaration, and that the bytes are valid UTF-8 containing only characters XML permits. It is not a validating parse: no DTD or schema is read.

For `json` the full RFC 8259 grammar is checked.

Empty contents are not well-formed in either format, so `False` is returned.

**Note:** The contents of this object are never modified by this method.

### StringBuilder.LastNLines

`Chilkat 11.7.0 · delphidll · StringBuilder · LastNLines · method · since 9.5.0.62`

```pascal
function CkStringBuilder_LastNLines(objHandle: HCkStringBuilder;
    numLines: Integer;
    bCrlf: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkStringBuilder__lastNLines(objHandle: HCkStringBuilder;
    numLines: Integer;
    bCrlf: wordbool): PWideChar; stdcall;
```

Returns the last N lines of the text. If fewer than `numLines` lines exists, then all of the text is returned. If `bCrlf` is `True`, then the line endings of the returned string are converted to CRLF, otherwise the line endings are converted to LF-only.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### StringBuilder.LoadFile

`Chilkat 11.7.0 · delphidll · StringBuilder · LoadFile · method · since 9.5.0.62`

```pascal
function CkStringBuilder_LoadFile(objHandle: HCkStringBuilder;
    path: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Loads the contents of a file.

Returns True for success, False for failure.

### StringBuilder.MarkdownToHtml

`Chilkat 11.7.0 · delphidll · StringBuilder · MarkdownToHtml · method · since 11.2.0`

```pascal
function CkStringBuilder_MarkdownToHtml(objHandle: HCkStringBuilder;
    options: HCkJsonObject;
    sbHtml: HCkStringBuilder): wordbool; stdcall;
```

This method converts the Markdown content of this object to HTML, storing the result in `sbHtml`. It supports both streaming and full document conversion. `options` specifies conversion options, including a key `streaming` option. In `streaming` mode, generated HTML is appended to `sbHtml`. In non-streaming mode, `sbHtml` is fully replaced by the generated HTML. For further details, see the examples linked below.

In `streaming` mode, only complete markdown lines are converted to HTML and removed from this object, leaving just the final partial line, if present. If this object contains only a partial markdown line, no HTML is emitted.

---

Starting in `v11.3.0` ...

- `"emitJavascript": true` can be included in `options` to emit Javascript function calls instead of HTML. This is used to update the response in an embedded browser in real-time. See [Real-Time Streaming AI Responses to Embedded Browsers in Desktop Apps](https://www.chilkatsoft.com/ai_real_time_ui_streaming.asp)
- `"streamingShell": true` is used to convert an empty string to an HTML shell to be used as the starting point before applying Javascript function calls. See [Preparing the HTML Shell](https://www.chilkatsoft.com/preparing_the_html_shell.asp)

- `"theme": "html_theme_name"` can be included when creating the HTML shell to select a predefined theme or when converting Markdown to HTML in non-streaming mode. The available themes are:
  - ChatGPT - A style that is similar to the ChatGPT application.
  - cleanWin - A clean style for Windows applications.
  - cleanMac - A clean style for MacOS applications.
  - raw - No HTML styles, header, or body begin/end elements are emitted. Only the Markdown to HTML generated elements are emitted.

  If no `theme` is is included, then default HTML docType/root/body/header elements are emitted unless various parts are overridden by `docType`, `rootElement`, `head`, `bodyStart`, `bodyEnd`, and `bodyExtra`.

- `"usesPrism": true` can be included when creating the HTML shell (or when converting Markdown to HTML in non-streaming mode) to include [PRISM code highlighting](https://prismjs.com/).

- `"prism": { "theme": "prism_theme_name" }` Is optional and can be used to specify the prism theme when `usesPrism` is `true`. Possible values are:
  - tomorrow
  - default
  - coy
  - dark
  - funky
  - okaidia
  - solarizedlight
  - twilight

- `"prism": { "version": "version_number" }` Is optional can can be used to specify the prism version, such as `"1.29.0"` when `usesPrism` is `true`. If not specified, then "1.29.0" is used.

- If no `theme` is specified, then any or all of the following HTML document parts can be explicitly specified:
  - `"docType": "doctype_element"` The `DOCTYPE` element. The default is `"<!DOCTYPE html>"`
  - `"rootElement": "root_element"` The `html` element. The default is `"<html>"`
  - `"head": "head_section"` The HTML fragment for the HTML head section. The default is `"<head><meta charset="utf-8" /></head>"`.  
    Note: If `usesPrism` is `true`, then prism related links will be inserted just before the `</head>`.
  - `"bodyStart": "html_fragment"` The HTML fragment to begin the body section. The default is `"<body><div id="content">"`
  - `"bodyEnd": "html_fragment"` The HTML fragment to end the body section. The default is `"</div><!-- end-of-content-div --></body>"`
  - `"noContentDiv": true` If set, the default bodyStart and bodyEnd do not include the `"<div id="content">"` and `"</div><!-- end-of-content-div -->"`

- `"copyButton": true` In non-streaming mode, can optionally be set to include HTML for adding a copy button. THe copy button is added by default in streaming mode.

- `"ChatGPT": { "max-width": "css_length"; }` Is optional can can be used to specify the max width of the body text if the `theme` is `ChatGPT`. The css_length is a length using CSS length units, such as `"72ch"`, `"40em"`, `"800px"`, etc.

Returns True for success, False for failure.

### StringBuilder.MaskQuotedStrings

`Chilkat 11.7.0 · delphidll · StringBuilder · MaskQuotedStrings · method · since 11.2.0`

```pascal
function CkStringBuilder_MaskQuotedStrings(objHandle: HCkStringBuilder;
    maskChar: PWideChar;
    quoteType: Integer;
    maskedStrings: HCkStringTable): wordbool; stdcall;
```

This function masks the content inside single and/or double-quoted strings by replacing it with a specified mask character (`maskChar`). The content of each masked quoted string is saved to `maskedStrings`. The contents can be restored by calling RestoreMaskedStrings.

`quoteType` determines which types of quoted strings are masked:

0. Both single and double quoted.
1. Only single quoted strings.
2. Only double quoted strings.

Returns True for success, False for failure.

### StringBuilder.Obfuscate

`Chilkat 11.7.0 · delphidll · StringBuilder · Obfuscate · method · since 9.5.0.80`

```pascal
procedure CkStringBuilder_Obfuscate(objHandle: HCkStringBuilder) stdcall;
```

Obfuscates the string. (The Unobfuscate method can be called to reverse the obfuscation to restore the original string.)

The Chilkat string obfuscation algorithm works by taking the utf-8 bytes of the string, base64 encoding it, and then scrambling the letters of the base64 encoded string. It is deterministic in that the same string will always obfuscate to the same result. It is NOT a secure way of encrypting a string. It is only meant to be a simple means of transforming a string into something unintelligible.

### StringBuilder.Prepend

`Chilkat 11.7.0 · delphidll · StringBuilder · Prepend · method · since 9.5.0.61`

```pascal
function CkStringBuilder_Prepend(objHandle: HCkStringBuilder;
    value: PWideChar): wordbool; stdcall;
```

Prepends a copy of the specified string to this instance.

Returns True for success, False for failure.

### StringBuilder.PunyDecode

`Chilkat 11.7.0 · delphidll · StringBuilder · PunyDecode · method · since 9.5.0.71`

```pascal
function CkStringBuilder_PunyDecode(objHandle: HCkStringBuilder): wordbool; stdcall;
```

In-place decodes the string from punycode.

Returns True for success, False for failure.

### StringBuilder.PunyEncode

`Chilkat 11.7.0 · delphidll · StringBuilder · PunyEncode · method · since 9.5.0.71`

```pascal
function CkStringBuilder_PunyEncode(objHandle: HCkStringBuilder): wordbool; stdcall;
```

In-place encodes the string to punycode.

Returns True for success, False for failure.

### StringBuilder.RegexMatch

`Chilkat 11.7.0 · delphidll · StringBuilder · RegexMatch · method · since 11.1.0`

```pascal
function CkStringBuilder_RegexMatch(objHandle: HCkStringBuilder;
    pattern: PWideChar;
    json: HCkJsonObject;
    timeoutMs: Integer): Integer; stdcall;
```

**Full documentation for this method (same in every language):** [Chilkat Uses PCRE2 (Perl Compatible Regular Expressions, version 2)](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_pcre2.md) · [Chilkat PCRE2 Performance](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_pcre2_performance.md)

Searches the content of this object for substrings that match a regular expression pattern and returns the matches in `json`. Returns the number of matches or -1 for failure. `timeoutMs` is the maximum number of milliseconds of processing allowed before giving up. Pass 0 for an infinite amount of time. Failure information is also returned in `json`.

### StringBuilder.RegexReplace

`Chilkat 11.7.0 · delphidll · StringBuilder · RegexReplace · method · since 11.1.0`

```pascal
function CkStringBuilder_RegexReplace(objHandle: HCkStringBuilder;
    json: HCkJsonObject): wordbool; stdcall;
```

**Full documentation for this method (same in every language):** [Chilkat Uses PCRE2 (Perl Compatible Regular Expressions, version 2)](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_pcre2.md) · [Chilkat PCRE2 Performance](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_pcre2_performance.md)

Replaces the substrings of capture groups found in a previous call to RegexMatch.

Returns True for success, False for failure.

### StringBuilder.RemoveAccents

`Chilkat 11.7.0 · delphidll · StringBuilder · RemoveAccents · method · since 9.5.0.91`

```pascal
function CkStringBuilder_RemoveAccents(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Removes the accents (diacritics) from European accented characters. This applies only to the accented characters found in the Windows-1252 (Latin alphabet) and Windows-1250 (Central European) charsets. Accent marks for characters in other languages will not be removed.

Returns True for success, False for failure.

### StringBuilder.RemoveAfterFinal

`Chilkat 11.7.0 · delphidll · StringBuilder · RemoveAfterFinal · method · since 9.5.0.77`

```pascal
function CkStringBuilder_RemoveAfterFinal(objHandle: HCkStringBuilder;
    marker: PWideChar): wordbool; stdcall;
```

Removes the substring found after the final occurrence of the `marker`. Also removes the `marker`. Returns `True` if the `marker` was found and content was removed. Otherwise returns `False`.

Returns True for success, False for failure.

### StringBuilder.RemoveBefore

`Chilkat 11.7.0 · delphidll · StringBuilder · RemoveBefore · method · since 9.5.0.77`

```pascal
function CkStringBuilder_RemoveBefore(objHandle: HCkStringBuilder;
    marker: PWideChar): wordbool; stdcall;
```

Removes the substring found before the 1st occurrence of the `marker`. Also removes the `marker`. Returns `True` if the `marker` was found and content was removed. Otherwise returns `False`.

Returns True for success, False for failure.

### StringBuilder.RemoveCharsAt

`Chilkat 11.7.0 · delphidll · StringBuilder · RemoveCharsAt · method · since 9.5.0.87`

```pascal
function CkStringBuilder_RemoveCharsAt(objHandle: HCkStringBuilder;
    startIndex: Integer;
    numChars: Integer): wordbool; stdcall;
```

Removes the specified range of characters from this instance.

Returns True for success, False for failure.

### StringBuilder.RemoveEmojis

`Chilkat 11.7.0 · delphidll · StringBuilder · RemoveEmojis · method · since 11.1.0`

```pascal
procedure CkStringBuilder_RemoveEmojis(objHandle: HCkStringBuilder) stdcall;
```

Removes all emoji characters from the string.

### StringBuilder.Replace

`Chilkat 11.7.0 · delphidll · StringBuilder · Replace · method · since 9.5.0.58`

```pascal
function CkStringBuilder_Replace(objHandle: HCkStringBuilder;
    value: PWideChar;
    replacement: PWideChar): Integer; stdcall;
```

Replaces all occurrences of a specified string in this instance with another specified string. Returns the number of replacements.

### StringBuilder.ReplaceAfterFinal

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceAfterFinal · method · since 9.5.0.73`

```pascal
function CkStringBuilder_ReplaceAfterFinal(objHandle: HCkStringBuilder;
    marker: PWideChar;
    replacement: PWideChar): wordbool; stdcall;
```

Replaces the content found after the final occurrence of `marker` with `replacement`.

Returns True for success, False for failure.

### StringBuilder.ReplaceAllBetween

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceAllBetween · method · since 9.5.0.64`

```pascal
function CkStringBuilder_ReplaceAllBetween(objHandle: HCkStringBuilder;
    beginMark: PWideChar;
    endMark: PWideChar;
    replacement: PWideChar;
    replaceMarks: wordbool): wordbool; stdcall;
```

Replaces the first occurrence of ALL the content found between `beginMark` and `endMark` with `replacement`. The `beginMark` and `endMark` are included in what is replaced if `replaceMarks` is `True`.

Returns True for success, False for failure.

### StringBuilder.ReplaceBetween

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceBetween · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ReplaceBetween(objHandle: HCkStringBuilder;
    beginMark: PWideChar;
    endMark: PWideChar;
    value: PWideChar;
    replacement: PWideChar): Integer; stdcall;
```

Replaces all occurrences of `value` with `replacement`, but only where `value` is found between `beginMark` and `endMark`. Returns the number of replacements made.

### StringBuilder.ReplaceFirst

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceFirst · method · since 9.5.0.77`

```pascal
function CkStringBuilder_ReplaceFirst(objHandle: HCkStringBuilder;
    value: PWideChar;
    replacement: PWideChar): wordbool; stdcall;
```

Replaces the first occurrence of a specified string in this instance with another string. Returns `True` if the `value` was found and replaced. Otherwise returns `False`.

Returns True for success, False for failure.

### StringBuilder.ReplaceI

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceI · method · since 9.5.0.67`

```pascal
function CkStringBuilder_ReplaceI(objHandle: HCkStringBuilder;
    value: PWideChar;
    replacement: Integer): Integer; stdcall;
```

Replaces all occurrences of `value` with the decimal integer `replacement`. Returns the number of replacements.

### StringBuilder.ReplaceNoCase

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceNoCase · method · since 9.5.0.82`

```pascal
function CkStringBuilder_ReplaceNoCase(objHandle: HCkStringBuilder;
    value: PWideChar;
    replacement: PWideChar): Integer; stdcall;
```

Replaces all occurrences of `value` with `replacement` (case insensitive). Returns the number of replacements.

### StringBuilder.ReplaceWord

`Chilkat 11.7.0 · delphidll · StringBuilder · ReplaceWord · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ReplaceWord(objHandle: HCkStringBuilder;
    value: PWideChar;
    replacement: PWideChar): Integer; stdcall;
```

Replaces all word occurrences of a specified string in this instance with another specified string. Returns the number of replacements made.

Important: This method is limited to replacing whole words in strings that only contains characters in the Latin1 charset (i.e. iso-8859-1 or Windows-1252). A whole word can only contain alphanumeric chars where the alpha chars are restricted to those of the Latin1 alpha chars. (The underscore character is also considered part of a word.)

### StringBuilder.RestoreMaskedStrings

`Chilkat 11.7.0 · delphidll · StringBuilder · RestoreMaskedStrings · method · since 11.2.0`

```pascal
function CkStringBuilder_RestoreMaskedStrings(objHandle: HCkStringBuilder;
    quoteType: Integer;
    maskedStrings: HCkStringTable): wordbool; stdcall;
```

Restores single and/or double-quoted strings previously masked by MaskQuotedStrings.

`quoteType` determines which types of quoted strings are masked:

0. Both single and double quoted.
1. Only single quoted strings.
2. Only double quoted strings.

Returns True for success, False for failure.

### StringBuilder.SecureClear

`Chilkat 11.7.0 · delphidll · StringBuilder · SecureClear · method · since 9.5.0.67`

```pascal
procedure CkStringBuilder_SecureClear(objHandle: HCkStringBuilder) stdcall;
```

Removes all characters from the current StringBuilder instance, and write zero bytes to the allocated memory before deallocating.

### StringBuilder.SetNth

`Chilkat 11.7.0 · delphidll · StringBuilder · SetNth · method · since 9.5.0.62`

```pascal
function CkStringBuilder_SetNth(objHandle: HCkStringBuilder;
    index: Integer;
    value: PWideChar;
    delimiterChar: PWideChar;
    exceptDoubleQuoted: wordbool;
    exceptEscaped: wordbool): wordbool; stdcall;
```

Sets the Nth substring in string in a list delimted by `delimiterChar`. The first substring is at index 0. If `exceptDoubleQuoted` is `True`, then the delimiter char found between double quotes is not treated as a delimiter. If `exceptEscaped` is `True`, then an escaped (with a backslash) delimiter char is not treated as a delimiter.

Returns True for success, False for failure.

### StringBuilder.SetString

`Chilkat 11.7.0 · delphidll · StringBuilder · SetString · method · since 9.5.0.61`

```pascal
function CkStringBuilder_SetString(objHandle: HCkStringBuilder;
    value: PWideChar): wordbool; stdcall;
```

Sets this instance to a copy of the specified string.

Returns True for success, False for failure.

### StringBuilder.Shorten

`Chilkat 11.7.0 · delphidll · StringBuilder · Shorten · method · since 9.5.0.87`

```pascal
function CkStringBuilder_Shorten(objHandle: HCkStringBuilder;
    numChars: Integer): wordbool; stdcall;
```

Shortens the string by removing the last `numChars` chars.

Returns True for success, False for failure.

### StringBuilder.StartsWith

`Chilkat 11.7.0 · delphidll · StringBuilder · StartsWith · method · since 9.5.0.62`

```pascal
function CkStringBuilder_StartsWith(objHandle: HCkStringBuilder;
    substr: PWideChar;
    caseSensitive: wordbool): wordbool; stdcall;
```

Returns `True` if the string starts with `substr`. Otherwise returns `False`. The comparison is case sensitive if `caseSensitive` is `True`, and case insensitive if `caseSensitive` is `False`.

### StringBuilder.ToCRLF

`Chilkat 11.7.0 · delphidll · StringBuilder · ToCRLF · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ToCRLF(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Converts line endings to CRLF (Windows) format.

Returns True for success, False for failure.

### StringBuilder.ToLF

`Chilkat 11.7.0 · delphidll · StringBuilder · ToLF · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ToLF(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Converts line endings to LF-only (UNIX) format.

Returns True for success, False for failure.

### StringBuilder.ToLowercase

`Chilkat 11.7.0 · delphidll · StringBuilder · ToLowercase · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ToLowercase(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Converts the contents to lowercase.

Returns True for success, False for failure.

### StringBuilder.ToUppercase

`Chilkat 11.7.0 · delphidll · StringBuilder · ToUppercase · method · since 9.5.0.62`

```pascal
function CkStringBuilder_ToUppercase(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Converts the contents to uppercase.

Returns True for success, False for failure.

### StringBuilder.Trim

`Chilkat 11.7.0 · delphidll · StringBuilder · Trim · method · since 9.5.0.62`

```pascal
function CkStringBuilder_Trim(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Trims whitespace from both ends of the string.

Returns True for success, False for failure.

### StringBuilder.TrimInsideSpaces

`Chilkat 11.7.0 · delphidll · StringBuilder · TrimInsideSpaces · method · since 9.5.0.62`

```pascal
function CkStringBuilder_TrimInsideSpaces(objHandle: HCkStringBuilder): wordbool; stdcall;
```

Replaces all tabs, CR's, and LF's, with SPACE chars, and removes extra SPACE's so there are no occurances of more than one SPACE char in a row.

Returns True for success, False for failure.

### StringBuilder.Unobfuscate

`Chilkat 11.7.0 · delphidll · StringBuilder · Unobfuscate · method · since 9.5.0.80`

```pascal
procedure CkStringBuilder_Unobfuscate(objHandle: HCkStringBuilder) stdcall;
```

Unobfuscates the string.

The Chilkat string obfuscation algorithm works by taking the utf-8 bytes of the string, base64 encoding it, and then scrambling the letters of the base64 encoded string. It is deterministic in that the same string will always obfuscate to the same result. It is not a secure way of encrypting a string. It is only meant to be a simple means of transforming a string into something unintelligible.

### StringBuilder.WriteFile

`Chilkat 11.7.0 · delphidll · StringBuilder · WriteFile · method · since 9.5.0.62`

```pascal
function CkStringBuilder_WriteFile(objHandle: HCkStringBuilder;
    path: PWideChar;
    charset: PWideChar;
    emitBom: wordbool): wordbool; stdcall;
```

Writes the contents to a file. If `emitBom` is `True`, then the BOM (also known as a preamble), is emitted for charsets that define a BOM (such as utf-8, utf-16, utf-32, etc.)

Returns True for success, False for failure.

### StringBuilder.WriteFileIfModified

`Chilkat 11.7.0 · delphidll · StringBuilder · WriteFileIfModified · method · since 9.5.0.73`

```pascal
function CkStringBuilder_WriteFileIfModified(objHandle: HCkStringBuilder;
    path: PWideChar;
    charset: PWideChar;
    emitBom: wordbool): wordbool; stdcall;
```

Writes the contents to a file, but only if it is a new file or if the contents are different than the existing file. If `emitBom` is `True`, then the BOM (also known as a preamble), is emitted for charsets that define a BOM (such as utf-8, utf-16, utf-32, etc.)

Returns True for success, False for failure.

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `AppendEncoded` | method | before 11.6.1 | — |
| `GetDecoded` | method | before 11.6.1 | — |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/BinData.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/JsonObject.md), [`StringTable`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/StringTable.md)

