<!DOCTYPE html>
<html  lang="en" >
<head>
<meta charset="utf-8">
<title>word-break: break-all, subjoined tibetan</title>
<meta name="assert" content="word-break: break-all means lines may break between any two typographic letter units.">
<link rel='help' href='https://drafts.csswg.org/css-text-3/#word-break-property'>
<link rel='match' href='reference/word-break-break-all-ref-005.html'>
<link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
<style type='text/css'>
.test { word-break: break-all; }
/* the CSS below is not part of the test */
.test, .ref { border: 1px solid orange;  margin: 20px;  padding: 10px; width: 390px; font: 36px/1.5 Arial; }
</style>
</head>
<body>
<div id='instructions'>Test passes if the two orange boxes are the same.</div>
<div class="test" lang="bo"><div id="testdiv"><span id="testspan">ལྷ་སའི་སྐད་ད་ལྟ</span></div></div>
<div class="ref" lang="bo"><span>ལྷ་སའི་སྐད་ད་<br/>ལྟ</span></div>
<script>
var sentenceWidth = document.getElementById('testspan').offsetWidth
document.getElementById('testdiv').style.width = String(sentenceWidth - 5)+'px'
</script>
</body>
</html>
