diff --git a/Frameworks/Foundation/JSAttributedString.js b/Frameworks/Foundation/JSAttributedString.js
index b423226f..40a0e96e 100644
--- a/Frameworks/Foundation/JSAttributedString.js
+++ b/Frameworks/Foundation/JSAttributedString.js
@@ -18,6 +18,7 @@
 // #import "JSTextAttachment.js"
 // #import "JSFont.js"
 // #import "JSColor.js"
+// #import "JSHTMLTextParser.js"
 'use strict';
 
 (function(){
@@ -197,6 +198,37 @@ JSClass("JSAttributedString", JSObject, {
         this.initWithAttachment(attachment);
     },
 
+    initWithHTML: function(html, options){
+        if (options === undefined){
+            options = {};
+        }
+        var string = "";
+        var run = JSAttributedStringRun(JSRange.Zero, {});
+        var runs = [run];
+        if (html !== null && html !== undefined){
+            var parser = JSHTMLTextParser.initWithHTML(html);
+            parser.delegate = {
+                htmlTextParserDidFindAttributedText: function(parser, text, attributes){
+                    if (run.range.length === 0){
+                        run.attributes = JSCopy(attributes);
+                        run.range.length += text.length;
+                    }else if (run.onlyContainsEqualAttributes(attributes)){
+                        run.range.length += text.length;
+                    }else{
+                        run = JSAttributedStringRun(JSRange(run.range.end, text.length), attributes);
+                        runs.push(run);
+                    }
+                    string += text;
+                }
+            };
+            parser.state.preserveWhitespace = options.preserveWhitespace === true;
+            parser.state.baseURL = options.baseURL || null;
+            parser.parse();
+        }
+        this._string = string;
+        this._runs = runs;
+    },
+
     // MARK: - Getting the unattributed string value
 
     getString: function(){
diff --git a/Frameworks/Foundation/JSHTMLTextParser.js b/Frameworks/Foundation/JSHTMLTextParser.js
new file mode 100644
index 00000000..1810e6fd
--- /dev/null
+++ b/Frameworks/Foundation/JSHTMLTextParser.js
@@ -0,0 +1,584 @@
+// #import "JSObject.js"
+// #import "JSProtocol.js"
+// #import "JSFont.js"
+"use strict";
+
+JSProtocol("JSHTMLTextParserDelegate", JSProtocol, {
+
+    htmlTextParserDidFindAttributedText: function(parser, text, attributes){
+    },
+
+});
+
+(function(){
+
+JSClass("JSHTMLTextParser", JSObject, {
+
+    html: null,
+    offset: null,
+    length: null,
+    delegate: null,
+
+    initWithHTML: function(html){
+        this.html = html;
+        this.offset = 0;
+        this.length = this.html.length;
+        this.state = Object.create(JSHTMLTextParser.State);
+        this.state.textAttributes = {};
+        this.stack = [this.state];
+    },
+
+    parse: function(){
+        var html = this.html;
+        var i = this.offset;
+        var l = this.length;
+        if (html === null || html === undefined){
+            return;
+        }
+        var elementName;
+        var entityName;
+        var attrName;
+        var attrValue;
+        var quote;
+        var elementAttributes;
+        var selfClosing = false;
+        while (i < l){
+            if (this.state.ignoringUntilEndTag){
+                if (html[i] === "<"){
+                    ++i;
+                    if (i < l && html[i] === "/"){
+                        ++i;
+                        if (html.substr(i, this.state.elementName.length).toLowerCase() === this.state.elementName){
+                            i += this.state.elementName.length;
+                            if (i < l && html[i] === ">"){
+                                ++i;
+                                this.popState();
+                            }
+                        }
+                    }
+                }else{
+                    ++i;
+                }
+            }else if (html[i] === "<"){
+                ++i;
+                if (i < l){
+                    if (isAlphabetic(html[i])){
+                        elementName = "";
+                        while (i < l && html[i] !== "/" && html[i] !== ">" && !isWhitespace(html[i])){
+                            if ((html[i] >= "A" && html[i] <= "Z")){
+                                elementName += html[i].toLowerCase();
+                            }else{
+                                elementName += html[i];
+                            }
+                            ++i;
+                        }
+                        elementAttributes = {};
+                        selfClosing = isVoidElement(elementName);
+                        if (i < l && html[i] === "/"){
+                            ++i;
+                        }
+                        while (i < l && html[i] !== ">"){
+                            while (i < l && isWhitespace(html[i])){
+                                ++i;
+                            }
+                            attrName = "";
+                            attrValue = "";
+                            while (i < l && html[i] !== "=" && html[i] !== "/" && html[i] !== ">" && !isWhitespace(html[i])){
+                                attrName += html[i];
+                                ++i;
+                            }
+                            while (i < l && isWhitespace(html[i])){
+                                ++i;
+                            }
+                            if (i < l && html[i] === "="){
+                                ++i;
+                                if (i < l && html[i] !== ">"){
+                                    if (html[i] === "\"" || html[i] === "'"){
+                                        quote = html[i];
+                                        ++i;
+                                        while (i < l && html[i] !== quote){
+                                            if (html[i] === "&"){
+                                                entityName = "";
+                                                while (i < l && (isEntityCharacter(html[i]))){
+                                                    entityName += html[i];
+                                                    ++i;
+                                                }
+                                                if (i < l && html[i] === ";"){
+                                                    ++i;
+                                                    attrValue += decodedEntity(entityName);
+                                                }else{
+                                                    attrValue += "&" + entityName;
+                                                }
+                                            }else{
+                                                attrValue += html[i];
+                                                ++i;
+                                            }
+                                        }
+                                        ++i;
+                                    }else{
+                                        while (i < l && html[i] !== "/" && html[i] !== ">" && !isWhitespace(html[i])){
+                                            attrValue += html[i];
+                                            ++i;
+                                        }
+                                    }
+                                }
+                            }
+                            if (i < l && html[i] === "/"){
+                                ++i;
+                            }
+                            elementAttributes[attrName] = attrValue;
+                        }
+                        ++i;
+                        this.beginElement(elementName, elementAttributes, selfClosing);
+                    }else if (html[i] === "/"){
+                        ++i;
+                        elementName = "";
+                        if (isAlphabetic(html[i])){
+                            while (i < l && html[i] !== "/" && html[i] !== ">" && !isWhitespace(html[i])){
+                                if ((html[i] >= "A" && html[i] <= "Z")){
+                                    elementName += html[i].toLowerCase();
+                                }else{
+                                    elementName += html[i];
+                                }
+                                ++i;
+                            }
+                        }
+                        while (i < l && html[i] !== ">"){
+                            ++i;
+                        }
+                        ++i;
+                        this.endElement(elementName);
+                    }else if (html[i] === "!" || html[i] === "?"){
+                        // valid comments or bogus markup...skipping
+                        // <!--
+                        // <!DOCTYPE
+                        // <![CDATA[
+                        // <?xml
+                        ++i;
+                        while (i < l && html[i] !== ">"){
+                            ++i;
+                        }
+                        ++i;
+                    }else{
+                        this.handleText("<");
+                    }
+                }else{
+                    this.handleText("<");
+                }
+            }else if (html[i] === "&"){
+                ++i;
+                entityName = "";
+                while (i < l && (isEntityCharacter(html[i]))){
+                    entityName += html[i];
+                    ++i;
+                }
+                if (i < l && html[i] === ";"){
+                    ++i;
+                    this.handleText(decodedEntity(entityName));
+                }else{
+                    this.handleText("&" + entityName);
+                }
+            }else{
+                if (this.state.preserveWhitespace){
+                    this.handleText(html[i]);
+                }else{
+                    if (isWhitespace(html[i])){
+                        if (this.trailingWhitespace === ""){
+                            this.handleTrailingWhitespace(html[i]);
+                        }
+                    }else{
+                        this.handleText(html[i]);
+                    }
+                }
+                ++i;
+            }
+        }
+        this.flush();
+    },
+
+    beginElement: function(elementName, elementAttributes, selfClosing){
+        if (isBlockElement(elementName)){
+            this.flushTrailingWhitespace();
+            if (this.recentText !== "" && !this.recentText.endsWith("\n") && !this.recentText.endsWith("\t")){
+                this.handleText("\n");
+            }
+        }
+        if (!selfClosing){
+            this.pushState(elementName, elementAttributes);
+
+            if (elementName === "ol"){
+                this.state.counter = {count: 1};
+            }else{
+                this.state.counter = null;
+            }
+
+            if (elementName === "script" || elementName === "style" || elementName === "template"){
+                this.state.ignoringUntilEndTag = true;
+            }else if (elementName === "h1"){
+                this.state.textAttributes.paragraphStyleName = "heading1";
+            }else if (elementName === "h2"){
+                this.state.textAttributes.paragraphStyleName = "heading2";
+            }else if (elementName === "h3"){
+                this.state.textAttributes.paragraphStyleName = "heading3";
+            }else if (elementName === "h4"){
+                this.state.textAttributes.paragraphStyleName = "heading4";
+            }else if (elementName === "h5"){
+                this.state.textAttributes.paragraphStyleName = "heading5";
+            }else if (elementName === "h6"){
+                this.state.textAttributes.paragraphStyleName = "heading6";
+            }else if (elementName === "b" || elementName === "strong"){
+                this.state.textAttributes.bold = true;
+            }else if (elementName === "i" || elementName === "em"){
+                this.state.textAttributes.italic = true;
+            }else if (elementName === "u"){
+                this.state.textAttributes.underline = true;
+            }else if (elementName === "s"){
+                this.state.textAttributes.strike = true;
+            }else if (elementName === "a"){
+                if (elementAttributes.href){
+                    this.state.textAttributes.link = JSURL.initWithString(elementAttributes.href, this.state.baseURL);
+                }
+            }else if (elementName === "li"){
+                var level = 0;
+                var stackIndex;
+                for (stackIndex = this.stack.length - 1; stackIndex >= 0; --stackIndex){
+                    if (this.stack[stackIndex].elementName === "ol" || this.stack[stackIndex].elementName === "ul"){
+                        ++level;
+                    }
+                }
+                if (level === 0){
+                    level = 1;
+                }
+                this.state.textAttributes.headIndent = 10 * level;
+            }else if (elementName === "pre"){
+                this.state.preserveWhitespace = true;
+            }
+            if (elementAttributes.style){
+                // TODO: CSS styles from element's style attr
+            }
+        }
+        if (elementName === "li"){
+            var parentState = this.stack[this.stack.length - 2];
+            if (parentState.counter !== null){
+                this.handleText("%d. ".sprintf(parentState.counter.count));
+                ++parentState.counter.count;
+            }else{
+                this.handleText("• ");
+            }
+        }else if (elementName === "br"){
+            this.flushTrailingWhitespace();
+            this.handleTrailingWhitespace("\n");
+        }else if (elementName === "hr"){
+            this.handleText("----------");
+            this.handleTrailingWhitespace("\n");
+        }
+    },
+
+    endElement: function(elementName){
+        elementName = elementName.toLowerCase();
+        if (this.stack[this.stack.length - 1].elementName === elementName){
+            if (elementName === "p"){
+                this.handleTrailingWhitespace("\n");
+            }else if (elementName === "div"){
+                this.handleTrailingWhitespace("\n");
+            }else if (elementName === "li"){
+                this.handleTrailingWhitespace("\n");
+            }else if (elementName === "th" || elementName === "td"){
+                this.handleTrailingWhitespace("\t");
+            }else if (elementName === "tr"){
+                this.handleTrailingWhitespace("\n");
+            }
+            this.popState();
+        }else{
+            // ingore mismatched end tag
+            // spec calls for more complicated behavior, but
+            // trying to keep things simple for now.
+        }
+    },
+
+    pushState: function(elementName, elementAttributes){
+        this.flush();
+        var state = Object.create(this.state);
+        state.textAttributes = JSCopy(state.textAttributes);
+        state.elementName = elementName;
+        state.elementAttributes = elementAttributes;
+        this.stack.push(state);
+        this.state = state;
+    },
+
+    popState: function(){
+        this.flush();
+        if (this.stack.length > 1){
+            this.stack.pop();
+            this.state = this.stack[this.stack.length - 1];
+        }
+    },
+
+    textBuffer: "",
+    textBufferAttributes: null,
+    recentText: "",
+    trailingWhitespace: "",
+
+    handleTrailingWhitespace: function(text){
+        this.recentText = text;
+        this.trailingWhitespace = text;
+        this.textBufferAttributes = this.state.textAttributes;
+    },
+
+    handleText: function(text){
+        this.flushTrailingWhitespace();
+        this.recentText = text;
+        this.textBuffer += text;
+        this.textBufferAttributes = this.state.textAttributes;
+    },
+
+    flushTrailingWhitespace: function(){
+        if (this.trailingWhitespace !== ""){
+            this.textBuffer += this.trailingWhitespace;
+            this.trailingWhitespace = "";
+            this.flush();
+        }
+    },
+
+    flush: function(){
+        if (this.textBuffer.length > 0){
+            if (this.delegate && this.delegate.htmlTextParserDidFindAttributedText){
+                this.delegate.htmlTextParserDidFindAttributedText(this, this.textBuffer, this.textBufferAttributes);
+            }
+            this.textBuffer = "";
+        }
+    }
+
+});
+
+JSHTMLTextParser.State = {
+    // html elements
+    elementName: null,
+    elementAttributes: null,
+    counter: null,
+    baseURL: null,
+
+    // options
+    preserveWhitespace: false,
+    ignoringUntilEndTag: false,
+
+    // text attributes
+    textAttributes: null,
+};
+
+var isWhitespace = function(c){
+    return c === " " || c === "\t" || c === "\n" || c === "\x0c";
+};
+
+var isEntityCharacter = function(c){
+    return isAlphabetic(c) || isNumeric(c);
+};
+
+var isAlphabetic = function(c){
+    if (c >= "a" && c <= "z"){
+        return true;
+    }
+    if (c >= "A" && c <= "Z"){
+        return true;
+    }
+    return false;
+};
+
+var isNumeric = function(c){
+    if (c >= "0" && c <= "9"){
+        return true;
+    }
+    return false;
+};
+
+var isVoidElement = function(name){
+    if (name === "area"){
+        return true;
+    }
+    if (name === "base"){
+        return true;
+    }
+    if (name === "br"){
+        return true;
+    }
+    if (name === "col"){
+        return true;
+    }
+    if (name === "embed"){
+        return true;
+    }
+    if (name === "hr"){
+        return true;
+    }
+    if (name === "img"){
+        return true;
+    }
+    if (name === "input"){
+        return true;
+    }
+    if (name === "link"){
+        return true;
+    }
+    if (name === "meta"){
+        return true;
+    }
+    if (name === "source"){
+        return true;
+    }
+    if (name === "track"){
+        return true;
+    }
+    if (name === "wbr"){
+        return true;
+    }
+    return false;
+};
+
+var isBlockElement = function(name){
+    if (name === "a"){
+        return false;
+    }
+    if (name === "em"){
+        return false;
+    }
+    if (name === "strong"){
+        return false;
+    }
+    if (name === "small"){
+        return false;
+    }
+    if (name === "s"){
+        return false;
+    }
+    if (name === "cite"){
+        return false;
+    }
+    if (name === "q"){
+        return false;
+    }
+    if (name === "dfn"){
+        return false;
+    }
+    if (name === "abbr"){
+        return false;
+    }
+    if (name === "ruby"){
+        return false;
+    }
+    if (name === "rt"){
+        return false;
+    }
+    if (name === "rp"){
+        return false;
+    }
+    if (name === "data"){
+        return false;
+    }
+    if (name === "time"){
+        return false;
+    }
+    if (name === "code"){
+        return false;
+    }
+    if (name === "var"){
+        return false;
+    }
+    if (name === "samp"){
+        return false;
+    }
+    if (name === "kbd"){
+        return false;
+    }
+    if (name === "sub"){
+        return false;
+    }
+    if (name === "sup"){
+        return false;
+    }
+    if (name === "i"){
+        return false;
+    }
+    if (name === "b"){
+        return false;
+    }
+    if (name === "u"){
+        return false;
+    }
+    if (name === "mark"){
+        return false;
+    }
+    if (name === "bdi"){
+        return false;
+    }
+    if (name === "bdo"){
+        return false;
+    }
+    if (name === "span"){
+        return false;
+    }
+    if (name === "br"){
+        return false;
+    }
+    if (name === "wbr"){
+        return false;
+    }
+    if (name === "picture"){
+        return false;
+    }
+    if (name === "source"){
+        return false;
+    }
+    if (name === "img"){
+        return false;
+    }
+    if (name === "label"){
+        return false;
+    }
+    if (name === "script"){
+        return false;
+    }
+    if (name === "template"){
+        return false;
+    }
+    if (name === "style"){
+        return false;
+    }
+    if (name === "base"){
+        return false;
+    }
+    return true;
+};
+
+var decodedEntity = function(name){
+    name = name.toLowerCase();
+    var value;
+    if (name.length > 0 && name[0] == "#"){
+        if (name.length > 1 && name[1] === "x"){
+            value = parseInt(name.substr(2), 16);
+        }else{
+            value = parseInt(name.substr(1));
+        }
+        if (!isNaN(value)){
+            return String.fromCharCode(value);
+        }
+    }else{
+        if (name === "lt"){
+            return "<";
+        }
+        if (name === "gt"){
+            return ">";
+        }
+        if (name === "amp"){
+            return "&";
+        }
+        if (name === "quot"){
+            return "\"";
+        }
+        if (name === "nbsp"){
+            return "\u00a0";
+        }
+    }
+    return "&" + name + ";";
+};
+
+})();
\ No newline at end of file
diff --git a/Tests/FoundationTests/JSAttributedStringTests.js b/Tests/FoundationTests/JSAttributedStringTests.js
index bd9586db..0240e023 100644
--- a/Tests/FoundationTests/JSAttributedStringTests.js
+++ b/Tests/FoundationTests/JSAttributedStringTests.js
@@ -84,6 +84,228 @@ JSClass('JSAttributedStringTests', TKTestSuite, {
         TKAssertExactEquals(attributes.test, 123);
     },
 
+    testInitWithHTML: function(){
+        var string = JSAttributedString.initWithHTML(null);
+        TKAssertExactEquals(string.string, "");
+        var range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 0);
+
+        string = JSAttributedString.initWithHTML(undefined);
+        TKAssertExactEquals(string.string, "");
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 0);
+
+        string = JSAttributedString.initWithHTML('');
+        TKAssertExactEquals(string.string, '');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 0);
+
+        string = JSAttributedString.initWithHTML('testing');
+        TKAssertExactEquals(string.string, 'testing');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 7);
+
+        string = JSAttributedString.initWithHTML('testing & test');
+        TKAssertExactEquals(string.string, 'testing & test');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 14);
+
+        string = JSAttributedString.initWithHTML('testing &amp; test');
+        TKAssertExactEquals(string.string, 'testing & test');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 14);
+
+        string = JSAttributedString.initWithHTML('testing < test');
+        TKAssertExactEquals(string.string, 'testing < test');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 14);
+
+        string = JSAttributedString.initWithHTML('testing &lt; test');
+        TKAssertExactEquals(string.string, 'testing < test');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 14);
+
+        string = JSAttributedString.initWithHTML('<b>testing</b>');
+        TKAssertExactEquals(string.string, 'testing');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 7);
+        var attrs = string.attributesAtIndex(0);
+        TKAssertExactEquals(attrs.bold, true);
+        attrs = string.attributesAtIndex(3);
+        TKAssertExactEquals(attrs.bold, true);
+        attrs = string.attributesAtIndex(4);
+        TKAssertExactEquals(attrs.bold, true);
+
+        string = JSAttributedString.initWithHTML('<i>testing</i>');
+        TKAssertExactEquals(string.string, 'testing');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 7);
+        attrs = string.attributesAtIndex(0);
+        TKAssertExactEquals(attrs.italic, true);
+        attrs = string.attributesAtIndex(3);
+        TKAssertExactEquals(attrs.italic, true);
+        attrs = string.attributesAtIndex(4);
+        TKAssertExactEquals(attrs.italic, true);
+
+        string = JSAttributedString.initWithHTML('<b>test</b>ing');
+        TKAssertExactEquals(string.string, 'testing');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+        range = string.rangeOfRunAtIndex(4);
+        TKAssertExactEquals(range.location, 4);
+        TKAssertExactEquals(range.length, 3);
+        attrs = string.attributesAtIndex(0);
+        TKAssertExactEquals(attrs.bold, true);
+        attrs = string.attributesAtIndex(3);
+        TKAssertExactEquals(attrs.bold, true);
+        attrs = string.attributesAtIndex(4);
+        TKAssertExactEquals(attrs.bold, undefined);
+
+        string = JSAttributedString.initWithHTML('<b><i>test</i></b>ing');
+        TKAssertExactEquals(string.string, "testing");
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+        range = string.rangeOfRunAtIndex(4);
+        TKAssertExactEquals(range.location, 4);
+        TKAssertExactEquals(range.length, 3);
+        attrs = string.attributesAtIndex(0);
+        TKAssertExactEquals(attrs.bold, true);
+        TKAssertExactEquals(attrs.italic, true);
+        attrs = string.attributesAtIndex(3);
+        TKAssertExactEquals(attrs.bold, true);
+        TKAssertExactEquals(attrs.italic, true);
+        attrs = string.attributesAtIndex(4);
+        TKAssertExactEquals(attrs.bold, undefined);
+        TKAssertExactEquals(attrs.italic, undefined);
+
+        string = JSAttributedString.initWithHTML('<i><b>test</i></b>ing');
+        TKAssertExactEquals(string.string, "testing");
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+        range = string.rangeOfRunAtIndex(4);
+        TKAssertExactEquals(range.location, 4);
+        TKAssertExactEquals(range.length, 3);
+        attrs = string.attributesAtIndex(0);
+        TKAssertExactEquals(attrs.bold, true);
+        TKAssertExactEquals(attrs.italic, true);
+        attrs = string.attributesAtIndex(3);
+        TKAssertExactEquals(attrs.bold, true);
+        TKAssertExactEquals(attrs.italic, true);
+        attrs = string.attributesAtIndex(4);
+        TKAssertExactEquals(attrs.bold, undefined);
+        TKAssertExactEquals(attrs.italic, true);
+
+        string = JSAttributedString.initWithHTML('test<br>one<br><br>two');
+        TKAssertExactEquals(string.string, 'test\none\n\ntwo');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 13);
+
+        string = JSAttributedString.initWithHTML('<div>test<br></div><div>one<br></div><div><br></div><div>two</div>');
+        TKAssertExactEquals(string.string, 'test\none\n\ntwo');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 13);
+
+        string = JSAttributedString.initWithHTML('<div>test</div><div>one</div><div></div><div>two</div>');
+        TKAssertExactEquals(string.string, 'test\none\n\ntwo');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 13);
+
+        string = JSAttributedString.initWithHTML('<p>test<br></p><p>one<br></p><p><br></p><p>two</p>');
+        TKAssertExactEquals(string.string, 'test\none\n\ntwo');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 13);
+
+        string = JSAttributedString.initWithHTML('<p>test</p><p>one</p><p></p><p>two</p>');
+        TKAssertExactEquals(string.string, 'test\none\n\ntwo');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 13);
+
+        string = JSAttributedString.initWithHTML('list:<li>one</li><li>two</li><li>three</li>');
+        TKAssertExactEquals(string.string, 'list:\n• one\n• two\n• three');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 6);
+        range = string.rangeOfRunAtIndex(6);
+        TKAssertExactEquals(range.location, 6);
+        TKAssertExactEquals(range.length, 19);
+        attrs = string.attributesAtIndex(0);
+        TKAssertExactEquals(attrs.headIndent, undefined);
+        attrs = string.attributesAtIndex(6);
+        TKAssertExactEquals(attrs.headIndent, 10);
+
+        string = JSAttributedString.initWithHTML('testing <42></42> tags');
+        TKAssertExactEquals(string.string, 'testing <42> tags');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 17);
+
+        string = JSAttributedString.initWithHTML('<><><><><><>');
+        TKAssertExactEquals(string.string, '<><><><><><>');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 12);
+
+        string = JSAttributedString.initWithHTML('<<<="">>>');
+        TKAssertExactEquals(string.string, '<<<="">>>');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 9);
+
+        string = JSAttributedString.initWithHTML('<div style=>test');
+        TKAssertExactEquals(string.string, 'test');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+
+        string = JSAttributedString.initWithHTML('<div style=/>test</div>');
+        TKAssertExactEquals(string.string, 'test');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+
+        string = JSAttributedString.initWithHTML('<div style=">test</div>');
+        TKAssertExactEquals(string.string, '');
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 0);
+
+        string = JSAttributedString.initWithHTML('<style type="text/css">&ignore; <this></style>test');
+        TKAssertExactEquals(string.string, "test");
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+
+        string = JSAttributedString.initWithHTML('<script type="text/javascript">&ignore; <this></script>test');
+        TKAssertExactEquals(string.string, "test");
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+
+        string = JSAttributedString.initWithHTML('<template>&ignore; <this></template>test');
+        TKAssertExactEquals(string.string, "test");
+        range = string.rangeOfRunAtIndex(0);
+        TKAssertExactEquals(range.location, 0);
+        TKAssertExactEquals(range.length, 4);
+    },
+
     testString: function(){
         var string = JSAttributedString.initWithString("Hello, world!");
         TKAssertNotNull(string);
@@ -1150,7 +1372,7 @@ JSClass('JSAttributedStringTests', TKTestSuite, {
         TKAssertExactEquals(range.location, 0);
         TKAssertExactEquals(range.length, 8);
         TKAssertExactEquals(attributes.textAlignment, JSTextAlignment.center);
-    }
+    },
     
 });