"hey <b>there</b>

"); assert.deepEqual(tokens, [startTag('div', [['id', 'foo', true]])]); }); QUnit.test('A tag with a double-quoted attribute', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [startTag('div', [['id', 'foo', true]])]); }); QUnit.test('A tag with a double-quoted empty', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [startTag('div', [['id', '', true]])]); }); QUnit.test('A tag with unquoted attribute', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [startTag('div', [['id', 'foo', false]])]); }); QUnit.test('A tag with valueless attributes', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [ startTag('div', [['foo', '', false], ['bar', '', false]]) ]); }); QUnit.test('Missing attribute name', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [ withSyntaxError( 'attribute name cannot start with equals sign', startTag('div', [['=foo', '', false]]) ) ]); }); QUnit.test('Invalid character in attribute name', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [ withSyntaxError( '" is not a valid character within attribute names', startTag('div', [['"', '', false]]) ) ]); }); QUnit.test('A tag with multiple attributes', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [ startTag('div', [ ['id', 'foo', false], ['class', 'bar baz', true], ['href', 'bat', true] ]) ]); }); QUnit.test('A tag with capitalization in attributes', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [startTag('img', [], true)]); }); QUnit.test( 'A self-closing tag with valueless attributes (regression)', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [ startTag('input', [['disabled', '', false]], true) ]); } ); QUnit.test( 'A self-closing tag with valueless attributes without space before closing (regression)', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [ startTag('input', [['disabled', '', false]], true) ]); } ); QUnit.test( 'A self-closing tag with an attribute with unquoted value without space before closing (regression)', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [ startTag('input', [['data-foo', 'bar', false]], true) ]); } ); QUnit.test('A tag with a / in the middle', function(assert) { let tokens = tokenize('

'); assert.deepEqual(tokens, [startTag('img', [['src', 'foo.png', true]])]); }); QUnit.test('An opening and closing tag with some content', function(assert) { let tokens = tokenize("

Some content

"); assert.deepEqual(tokens, [ startTag('div', [['id', 'foo', true], ['class', '{{bar}} baz', true]]), chars('Some content'), endTag('div') ]); }); QUnit.test('A comment', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment(' hello ')]); }); QUnit.test('A (buggy) comment with no ending --', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment()]); }); QUnit.test('A comment that immediately closes', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment()]); }); QUnit.test('A comment that contains a -', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A perfectly legal - appears ')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A perfectly legal - ')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A perfectly legal- ')]); }); QUnit.test('A (buggy) comment that contains two --', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable -- appears ')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable -- ')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable-- ')]); }); QUnit.test('A (buggy) comment ending with more than two --', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable but legal comment -')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable but legal comment-')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable but legal comment - -')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable but legal comment -- -')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment(' A questionable but legal comment ----')]); }); QUnit.test('A (buggy) comment starting with more than two --', function(assert) { let tokens = tokenize(''); assert.deepEqual(tokens, [comment('- Questionable but legal ')]); tokens = tokenize(''); assert.deepEqual(tokens, [comment('-Questionable but legal ')]); }); QUnit.skip('Character references are expanded', function(assert) { let tokens = tokenize( '"Foo & Bar" < << < < ≧̸ &Borksnorlax; ≦̸' ); assert.deepEqual(tokens, [chars('"Foo & Bar" < << < < ≧̸ &Borksnorlax; ≦̸')]); tokens = tokenize( "

" ); assert.deepEqual(tokens, [ startTag('div', [ ['title', '"Foo & Bar" ▒ < << < < ≧̸ &Borksnorlax; ≦̸', true] ]) ]); }); // https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions QUnit.test('A newline immediately following a

 tag is stripped', function(assert) {
  let tokens = tokenize("\nhello");
  assert.deepEqual(tokens, [startTag('pre'), chars('hello'), endTag('pre')]);
});

QUnit.test('A newline immediately following a closing

tag is not stripped', function(assert) { let tokens = tokenize("\n

\nhello

\n"); assert.deepEqual(tokens, [chars('\n'), startTag('pre'), chars('hello'), endTag('pre'), chars('\n')]); }); // https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions QUnit.test('A newline immediately following a

 tag is stripped', function(assert) {
  let tokens = tokenize("\nhello");
  assert.deepEqual(tokens, [startTag('PRE'), chars('hello'), endTag('PRE')]);
});

// https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
QUnit.test('A newline immediately following a  tag is stripped', function(assert) {
  let tokens = tokenize("<textarea>\nhello");
  assert.deepEqual(tokens, [startTag('textarea'), chars('hello'), endTag('textarea')]);
});

// https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
QUnit.test('codemod: A newline immediately following a  tag is stripped', function(assert) {
  let tokens = tokenize("\nhello", { mode: 'codemod' });
  assert.deepEqual(tokens, [startTag('pre'), chars('\nhello'), endTag('pre')]);
});

QUnit.test('codemod: A newline immediately following a closing  tag is not stripped', function(assert) {
  let tokens = tokenize("\n\nhello\n", { mode: 'codemod' });
  assert.deepEqual(tokens, [chars('\n'), startTag('pre'), chars('\nhello'), endTag('pre'), chars('\n')]);
});

// https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
QUnit.test('codemod: A newline immediately following a  tag is stripped', function(assert) {
  let tokens = tokenize("\nhello", { mode: 'codemod' });
  assert.deepEqual(tokens, [startTag('PRE'), chars('\nhello'), endTag('PRE')]);
});

// https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
QUnit.test('codemod: A newline immediately following a  tag is stripped', function(assert) {
  let tokens = tokenize("<textarea>\nhello", { mode: 'codemod' });
  assert.deepEqual(tokens, [startTag('textarea'), chars('\nhello'), endTag('textarea')]);
});

// https://html.spec.whatwg.org/multipage/semantics.html#the-title-element
QUnit.test('The title element content is always text', function(assert) {
  let tokens = tokenize(""hey <b>there</b><!-- comment -->");
  assert.deepEqual(tokens, [startTag('title'), chars('"hey there'), endTag('title')]);
});

// https://github.com/emberjs/ember.js/issues/18530
QUnit.test('Title element content is not text', function(assert) {
  let tokens = tokenize("<!-- hello -->");
  assert.deepEqual(tokens, [startTag('Title'), comment(' hello '), endTag('Title')]);
});

// https://html.spec.whatwg.org/multipage/semantics.html#the-style-element
QUnit.test('The style element content is always text', function(assert) {
  let tokens = tokenize("");
  assert.deepEqual(tokens, [startTag('style'), chars('"hey there'), endTag('style')]);
});

// https://html.spec.whatwg.org/multipage/scripting.html#restrictions-for-contents-of-script-elements
QUnit.test('The script element content restrictions', function(assert) {
  let tokens = tokenize("");
  assert.deepEqual(tokens, [startTag('script'), chars('"hey there'), endTag('script')]);
});

QUnit.test('Two following script tags', function(assert) {
  let tokens = tokenize(" ");

  assert.deepEqual(tokens, [
    startTag('script'),
    chars(''),
    endTag('script'),
    chars(' '),
    startTag('script'),
    chars('second'),
    endTag('script')
  ]);
});

// https://github.com/emberjs/rfcs/blob/master/text/0311-angle-bracket-invocation.md#dynamic-invocations
QUnit.test('An Emberish named arg invocation', function(assert) {
  let tokens = tokenize('<@foo>');
  assert.deepEqual(tokens, [startTag('@foo'), endTag('@foo')]);
});

QUnit.test('Parsing `;

  let tokens = tokenize(input);
  assert.deepEqual(tokens, [
    doctype(),
    startTag('html'),
    startTag('head'),
    startTag('script', [['src','/foo.js', true]]),
    endTag('script'),
    startTag('script', [['src','/bar.js', true]]),
    endTag('script'),
    startTag('script', [['src','/baz.js', true]]),
    endTag('script'),
    endTag('head'),
    endTag('html'),
  ]);
});

QUnit.module('simple-html-tokenizer - preprocessing');

QUnit.test('Carriage returns are replaced with line feeds', function(assert) {
  let tokens = tokenize('\r\r\n\r\r\n\n');
  assert.deepEqual(tokens, [chars('\n\n\n\n\n')]);
});

QUnit.module('simple-html-tokenizer - location info');

QUnit.test('lines are counted correctly', function(assert) {
  let tokens = tokenize('\r\r\n\r\r\n\n', { loc: true });
  assert.deepEqual(tokens, [locInfo(chars('\n\n\n\n\n'), 1, 0, 6, 0)]);
});

QUnit.test('tokens: Chars', function(assert) {
  let tokens = tokenize('Chars', { loc: true });
  assert.deepEqual(tokens, [locInfo(chars('Chars'), 1, 0, 1, 5)]);
});

QUnit.test('tokens: Chars start-tag Chars', function(assert) {
  let tokens = tokenize('CharsChars', { loc: true });
  assert.deepEqual(tokens, [
    locInfo(chars('Chars'), 1, 0, 1, 5),
    locInfo(startTag('div'), 1, 5, 1, 10),
    locInfo(chars('Chars'), 1, 10, 1, 15)
  ]);
});

QUnit.test('tokens: start-tag start-tag', function(assert) {
  let tokens = tokenize('', { loc: true });
  assert.deepEqual(tokens, [
    locInfo(startTag('div'), 1, 0, 1, 5),
    locInfo(startTag('div'), 1, 5, 1, 10)
  ]);
});

QUnit.test('tokens: html char ref start-tag', function(assert) {
  let tokens = tokenize('>', { loc: true });
  assert.deepEqual(tokens, [
    locInfo(chars('>'), 1, 0, 1, 4),
    locInfo(startTag('div'), 1, 4, 1, 9)
  ]);
});

QUnit.test('tokens: Chars start-tag Chars start-tag', function(assert) {
  let tokens = tokenize('Chars\nChars\n', {
    loc: true
  });
  assert.deepEqual(tokens, [
    locInfo(chars('Chars\n'), 1, 0, 2, 0),
    locInfo(startTag('div'), 2, 0, 2, 5),
    locInfo(chars('Chars\n'), 2, 5, 3, 0),
    locInfo(startTag('div'), 3, 0, 3, 5)
  ]);
});

QUnit.test('tokens: comment start-tag Chars end-tag', function(assert) {
  let tokens = tokenize(
    'Chars\n',
    { loc: true }
  );
  assert.deepEqual(tokens, [
    locInfo(comment(' multline\ncomment '), 1, 0, 2, 11),
    locInfo(startTag('div', [['foo', 'bar', false]]), 2, 11, 2, 24),
    locInfo(chars('Chars\n'), 2, 24, 3, 0),
    locInfo(endTag('div'), 3, 0, 3, 6)
  ]);
});

function chars(s?: string): Chars {
  return {
    type: TokenType.Chars,
    chars: s === undefined ? '' : s
  };
}

function comment(s?: string): Comment {
  return {
    type: TokenType.Comment,
    chars: s === undefined ? '' : s
  };
}

function startTag(
  tagName: string,
  attributes?: Attribute[],
  selfClosing?: boolean
): StartTag {
  return {
    type: TokenType.StartTag,
    tagName: tagName,
    attributes: attributes === undefined ? [] : attributes,
    selfClosing: selfClosing === undefined ? false : selfClosing
  };
}

function endTag(tagName: string): EndTag {
  return {
    type: TokenType.EndTag,
    tagName: tagName
  };
}

function doctype(publicIdentifier?: string, systemIdentifier?: string): Doctype {
  let doctype: Doctype = {
    type: TokenType.Doctype,
    name: 'html',
  };

  if (publicIdentifier) {
    doctype.publicIdentifier = publicIdentifier;
  }

  if (systemIdentifier) {
    doctype.systemIdentifier = systemIdentifier;
  }

  return doctype;
}

function locInfo(
  token: Token,
  startLine: number,
  startColumn: number,
  endLine: number,
  endColumn: number
) {
  token.loc = {
    start: {
      line: startLine,
      column: startColumn
    },
    end: {
      line: endLine,
      column: endColumn
    }
  };

  return token;
}

function withSyntaxError(message: string, result: Token) {
  result.syntaxError = message;
  return result;
}