Add optional support for source locations

src/index.ts

@@ -1,5 +1,5 @@
 import {Parser, ParserOptions} from 'htmlparser2';
-import {Directive, Node, Options, Attributes} from '../types/index.d';
+import {Directive, Node, NodeTag, Options, Attributes} from '../types/index.d';
 
 const defaultOptions: ParserOptions = {
   lowerCaseTags: false,
@@ -49,6 +49,34 @@ const parser = (html: string, options: Options = {}): Node[] => {
     return result;
   }
 
+  const lastLoc = {
+    line: 1,
+    column: 1
+  };
+
+  let lastIndex = 0;
+  function getLoc(index: number) {
+    if (index < lastIndex) {
+      throw new Error('Source indices must be monotonic');
+    }
+
+    while (lastIndex < index) {
+      if (html.charCodeAt(lastIndex) === /* \n */ 10) {
+        lastLoc.line++;
+        lastLoc.column = 1;
+      } else {
+        lastLoc.column++;
+      }
+
+      lastIndex++;
+    }
+
+    return {
+      line: lastLoc.line,
+      column: lastLoc.column
+    };
+  }
+
   function onprocessinginstruction(name: string, data: string) {
     const directives = defaultDirectives.concat(options.directives ?? []);
     const last: Node = bufferArrayLast();
@@ -92,7 +120,15 @@ const parser = (html: string, options: Options = {}): Node[] => {
   }
 
   function onopentag(tag: string, attrs: Attributes) {
-    const buf: Node = {tag};
+    const start = getLoc(parser.startIndex);
+    const buf: NodeTag = {tag};
+
+    if (options.sourceLocations) {
+      buf.loc = {
+        start,
+        end: start
+      };
+    }
 
     if (Object.keys(attrs).length > 0) {
       buf.attrs = normalizeArributes(attrs);
@@ -104,6 +140,10 @@ const parser = (html: string, options: Options = {}): Node[] => {
   function onclosetag() {
     const buf: Node | undefined = bufArray.pop();
 
+    if (buf && typeof buf === 'object' && buf.loc && parser.endIndex !== null) {
+      buf.loc.end = getLoc(parser.endIndex);
+    }
+
     if (buf) {
       const last = bufferArrayLast();
 

test/test-core.spec.ts

@@ -240,3 +240,55 @@ test('should be not converting html entity name', t => {
   const expected = ['‌ ©'];
   t.deepEqual(tree, expected);
 });
+
+test('should parse with source locations', t => {
+  const html = '<h1>Test</h1>\n<p><b>Foo</b></p>';
+  const tree = parser(html, {sourceLocations: true});
+  const expected = [
+    {
+      tag: 'h1',
+      content: ['Test'],
+      loc: {
+        start: {
+          line: 1,
+          column: 1
+        },
+        end: {
+          line: 1,
+          column: 13
+        }
+      }
+    },
+    '\n',
+    {
+      tag: 'p',
+      content: [
+        {
+          tag: 'b',
+          content: ['Foo'],
+          loc: {
+            start: {
+              line: 2,
+              column: 4
+            },
+            end: {
+              line: 2,
+              column: 13
+            }
+          }
+        }
+      ],
+      loc: {
+        start: {
+          line: 2,
+          column: 1
+        },
+        end: {
+          line: 2,
+          column: 17
+        }
+      }
+    }
+  ];
+  t.deepEqual(tree, expected);
+});

types/index.d.ts

@@ -12,6 +12,7 @@ export type Directive = {
 
 export type Options = {
   directives?: Directive[];
+  sourceLocations?: boolean;
 } & ParserOptions;
 
 export type Node = NodeText | NodeTag;
@@ -20,6 +21,16 @@ export type NodeTag = {
   tag?: string | boolean;
   attrs?: Attributes;
   content?: Node[];
+  loc?: SourceLocation;
 };
 
 export type Attributes = Record<string, string>;
+export type SourceLocation = {
+  start: Position;
+  end: Position;
+};
+
+export type Position = {
+  line: number;
+  column: number;
+};