herb 0.10.4-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/templates/javascript/packages/core/src/html-constants.ts.erb

@@ -0,0 +1,32 @@
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
+export const HTML_BOOLEAN_ATTRIBUTES = new Set([
+<%- boolean_attributes.each do |attribute| -%>
+  <%= attribute.inspect %>,
+<%- end -%>
+])
+
+export function isBooleanAttribute(attributeName: string): boolean {
+  return HTML_BOOLEAN_ATTRIBUTES.has(attributeName.toLowerCase())
+}
+
+// https://html.spec.whatwg.org/multipage/rendering.html#the-page
+export const HTML_WHITESPACE_PRESERVING_ELEMENTS: ReadonlySet<string> = new Set([
+<%- whitespace_preserving_elements.each do |element| -%>
+  <%= element.inspect %>,
+<%- end -%>
+])
+
+export function isWhitespacePreservingElement(tagName: string): boolean {
+  return HTML_WHITESPACE_PRESERVING_ELEMENTS.has(tagName.toLowerCase())
+}
+
+// https://html.spec.whatwg.org/multipage/rendering.html#phrasing-content-3
+export const HTML_INLINE_ELEMENTS: ReadonlySet<string> = new Set([
+<%- inline_elements.each do |element| -%>
+  <%= element.inspect %>,
+<%- end -%>
+])
+
+export function isInlineElement(tagName: string): boolean {
+  return HTML_INLINE_ELEMENTS.has(tagName.toLowerCase())
+}

data/templates/javascript/packages/core/src/html-elements.ts.erb

@@ -0,0 +1,41 @@
+// https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// https://html.spec.whatwg.org/multipage/obsolete.html#non-conforming-features
+
+export interface HTMLElementInfo {
+  name: string
+  description: string
+  isVoid: boolean
+  isDeprecated: boolean
+}
+
+export const HTML_ELEMENTS: HTMLElementInfo[] = [
+<%- html_elements.each do |element| -%>
+  { name: <%= element.name.inspect %>, description: <%= element.description.inspect %>, isVoid: <%= element.void? %>, isDeprecated: <%= element.deprecated? %> },
+<%- end -%>
+]
+
+export const HTML_ELEMENT_NAMES = new Set(HTML_ELEMENTS.map(element => element.name))
+
+export const HTML_VOID_ELEMENTS = new Set(
+  HTML_ELEMENTS.filter(element => element.isVoid).map(element => element.name),
+)
+
+export const HTML_DEPRECATED_ELEMENTS = new Set(
+  HTML_ELEMENTS.filter(element => element.isDeprecated).map(element => element.name),
+)
+
+export function isKnownHTMLElement(tagName: string): boolean {
+  return HTML_ELEMENT_NAMES.has(tagName.toLowerCase())
+}
+
+export function isVoidElement(tagName: string): boolean {
+  return HTML_VOID_ELEMENTS.has(tagName.toLowerCase())
+}
+
+export function isDeprecatedElement(tagName: string): boolean {
+  return HTML_DEPRECATED_ELEMENTS.has(tagName.toLowerCase())
+}
+
+export function isCustomElement(tagName: string): boolean {
+  return tagName.includes("-")
+}

data/templates/javascript/packages/core/src/node-type-guards.ts.erb

@@ -1,4 +1,4 @@
-import type { Node, NodeType, ERBNode } from "./nodes.js"
+import type { Node, NodeType, ERBNode, HTMLNode } from "./nodes.js"
 
 import { Token } from "./token.js"
 import { ParseResult } from "./parse-result.js"
@@ -34,16 +34,20 @@ export function is<%= node.name %>(node: Node | null | undefined): node is <%=
 /**
  * Checks if a node is any HTML node type
  */
-export function isHTMLNode(node: Node): boolean {
-<%- html_nodes = nodes.select { |n| n.name.start_with?("HTML") } -%>
+export function isHTMLNode(node: Node | null | undefined): node is HTMLNode {
+  if (!node) return false
+
+<%- html_nodes = nodes.select(&:html?) -%>
   return <%= html_nodes.map { |n| "is#{n.name}(node)" }.join(" ||\n         ") %>
 }
 
 /**
  * Checks if a node is any ERB node type
  */
-export function isERBNode(node: Node): node is ERBNode {
-<%- erb_nodes = nodes.select { |n| n.name.start_with?("ERB") } -%>
+export function isERBNode(node: Node | null | undefined): node is ERBNode {
+  if (!node) return false
+
+<%- erb_nodes = nodes.select(&:erb_tag?) -%>
   return <%= erb_nodes.map { |n| "is#{n.name}(node)" }.join(" ||\n         ") %>
 }
 
@@ -176,7 +180,7 @@ export function areAllOfType<T extends (new (...args: any[]) => Node)[]>(
 
 export function areAllOfType(
   nodes: Node[],
-  ...types: Array<(node: Node) => boolean>
+  ...types: Array<NodeType | (new (...args: any[]) => Node) | ((node: Node) => boolean)>
 ): boolean
 
 export function areAllOfType(
@@ -220,7 +224,7 @@ export function filterNodes<T extends (new (...args: any[]) => Node)[]>(
 
 export function filterNodes(
   nodes: Node[] | undefined | null,
-  ...types: Array<(node: Node) => boolean>
+  ...types: Array<NodeType | (new (...args: any[]) => Node) | ((node: Node) => boolean)>
 ): Node[]
 
 export function filterNodes(

data/templates/javascript/packages/core/src/nodes.ts.erb

@@ -1,4 +1,5 @@
 import { Location } from "./location.js"
+import { locate, locatable } from "./locate.js"
 import { Token, SerializedToken } from "./token.js"
 import { HerbError } from "./errors.js"
 import { deserializePrismNode, inspectPrismSerialized } from "./prism/index.js"
@@ -7,6 +8,8 @@ import type { PrismNode } from "./prism/index.js"
 import type { SerializedLocation } from "./location.js"
 import type { SerializedHerbError } from "./errors.js"
 import type { Visitor } from "./visitor.js"
+import type { Position } from "./position.js"
+import type { LocateResult } from "./locate.js"
 
 export type SerializedNodeType = string
 
@@ -42,6 +45,14 @@ export abstract class Node implements BaseNodeProps {
     this.errors = errors
   }
 
+  locate(position: Position): LocateResult | null {
+    return locate(this, position)
+  }
+
+  locatable(position: Position): boolean {
+    return locatable(this, position)
+  }
+
   setSource(source: string): void {
     this.source = source
     this.compactChildNodes().forEach(child => child.setSource(source))
@@ -50,7 +61,7 @@ export abstract class Node implements BaseNodeProps {
   toJSON(): SerializedNode {
     return {
       type: this.type,
-      location: this.location.toJSON(),
+      location: this.location ? this.location.toJSON() : (null as unknown as SerializedLocation),
       errors: this.errors,
     }
   }
@@ -72,7 +83,13 @@ export abstract class Node implements BaseNodeProps {
   }
 
   abstract treeInspect(indent?: number): string
-  abstract recursiveErrors(): HerbError[]
+  recursiveErrors(): HerbError[] {
+    const accumulator: HerbError[] = []
+    this.collectErrors(accumulator)
+    return accumulator
+  }
+
+  abstract collectErrors(accumulator: HerbError[]): void
   abstract accept(visitor: Visitor): void
   abstract childNodes(): (Node | null | undefined)[]
   abstract compactChildNodes(): Node[]
@@ -254,7 +271,7 @@ export class <%= node.name %> extends Node {
   static from(data: Serialized<%= node.name %>): <%= node.name %> {
     return new <%= node.name %>({
       type: data.type,
-      location: Location.from(data.location),
+      location: Location.fromOptional(data.location),
       errors: (data.errors || []).map(error => HerbError.from(error)),
       <%- node.fields.each do |field| -%>
       <%- case field -%>
@@ -289,6 +306,31 @@ export class <%= node.name %> extends Node {
     })
   }
 
+  static build(props: Partial<Omit<<%= node.name %>Props, "type">> = {}): <%= node.name %> {
+    return new <%= node.name %>({
+      type: "<%= node.type %>",
+      location: Location.zero,
+      errors: [],
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::StringField, Herb::Template::ElementSourceField -%>
+      <%= field.name %>: "",
+      <%- when Herb::Template::BooleanField -%>
+      <%= field.name %>: false,
+      <%- when Herb::Template::ArrayField -%>
+      <%= field.name %>: [],
+      <%- when Herb::Template::TokenField, Herb::Template::LocationField, Herb::Template::NodeField, Herb::Template::BorrowedNodeField, Herb::Template::PrismSerializedField, Herb::Template::PrismNodeField -%>
+      <%= field.name %>: null,
+      <%- when Herb::Template::AnalyzedRubyField, Herb::Template::PrismContextField -%>
+      // no-op for <%= field.name %>
+      <%- else -%>
+      <% raise "Unhandled class #{field.class}" %>
+      <%- end -%>
+      <%- end -%>
+      ...props,
+    })
+  }
+
   constructor(props: <%= node.name %>Props) {
     super(props.type, props.location, props.errors);
     <%- node.fields.each do |field| -%>
@@ -350,18 +392,16 @@ export class <%= node.name %> extends Node {
   }
   <%- end -%>
 
-  recursiveErrors(): HerbError[] {
-    return [
-      ...this.errors,
-      <%- node.fields.each do |field| -%>
-      <%- case field -%>
-      <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
-      this.<%= field.name %> ? this.<%= field.name %>.recursiveErrors() : [],
-      <%- when Herb::Template::ArrayField -%>
-      ...this.<%= field.name %>.map(node => node.recursiveErrors()),
-      <%- end -%>
-      <%- end -%>
-    ].flat();
+  collectErrors(accumulator: HerbError[]): void {
+    if (this.errors.length > 0) accumulator.push(...this.errors);
+    <%- node.fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
+    this.<%= field.name %>?.collectErrors(accumulator);
+    <%- when Herb::Template::ArrayField -%>
+    for (const node of this.<%= field.name %>) node.collectErrors(accumulator);
+    <%- end -%>
+    <%- end -%>
   }
 
   toJSON(): Serialized<%= node.name %> {
@@ -398,7 +438,7 @@ export class <%= node.name %> extends Node {
   treeInspect(): string {
     let output = "";
 
-    output += `@ <%= node.name %> ${this.location.treeInspectWithLabel()}\n`;
+    output += `@ <%= node.name %> ${this.location ? this.location.treeInspectWithLabel() : "(location: ∅)"}\n`;
     output += `├── errors: ${this.inspectArray(this.errors, "<%= node.fields.any? ? "│   " : "    " %>")}`;
     <%- node.field_visibilities.each do |visibility| -%>
     <%- field = visibility.field -%>
@@ -493,17 +533,40 @@ export type NodeType =
   | "<%= node.type %>"
   <%- end -%>
 
-export type ERBNodeType = Extract<NodeType, `AST_ERB_${string}`>;
+export type HTMLNodeType =
+  <%- nodes.each do |node| -%>
+    <%- next unless node.html? -%>
+  | "<%= node.type %>"
+  <%- end -%>
+
+export type HTMLNode =
+  <%- nodes.each do |node| -%>
+    <%- next unless node.html? -%>
+  | <%= node.name %>
+  <%- end -%>
+
+export const HTMLNodeClasses = [
+  <%- nodes.each do |node| -%>
+  <%- next unless node.html? -%>
+  <%= node.name %>,
+  <%- end -%>
+]
+
+export type ERBNodeType =
+  <%- nodes.each do |node| -%>
+    <%- next unless node.erb_tag? -%>
+  | "<%= node.type %>"
+  <%- end -%>
 
 export type ERBNode =
   <%- nodes.each_with_index.map do |node, index| -%>
-    <%- next unless node.name.start_with?("ERB") -%>
+    <%- next unless node.erb_tag? -%>
   | <%= node.name %>
   <%- end -%>
 
 export const ERBNodeClasses = [
   <%- nodes.each_with_index.map do |node, index| -%>
-  <%- next unless node.name.start_with?("ERB") -%>
+  <%- next unless node.erb_tag? -%>
   <%= node.name %>,
   <%- end -%>
 ]

data/templates/javascript/packages/core/src/parser-options.ts.erb

@@ -0,0 +1,41 @@
+export interface LexOptions {
+<%- parser_options.lex_fields_for(:javascript).each do |field| -%>
+  /** <%= field.description %> */
+  <%= field.snake_case %>?: <%= field.typescript_type %>
+<%- end -%>
+}
+
+export interface ParseOptions extends LexOptions {
+<%- parser_options.parse_fields_for(:javascript).each do |field| -%>
+  /** <%= field.description %> */
+  <%= field.snake_case %>?: <%= field.typescript_type %>
+<%- end -%>
+}
+
+export type SerializedParserOptions = Required<ParseOptions>
+
+export const DEFAULT_PARSER_OPTIONS: SerializedParserOptions = {
+<%- parser_options.fields_for(:javascript).each do |field| -%>
+  <%= field.snake_case %>: <%= field.js_default %>,
+<%- end -%>
+}
+
+/**
+ * Represents the parser options used during parsing.
+ */
+export class ParserOptions {
+<%- parser_options.fields_for(:javascript).each do |field| -%>
+  /** <%= field.description %> */
+  readonly <%= field.snake_case %>: <%= field.typescript_type %>
+
+<%- end -%>
+  static from(options: SerializedParserOptions): ParserOptions {
+    return new ParserOptions(options)
+  }
+
+  constructor(options: ParseOptions = {}) {
+  <%- parser_options.fields_for(:javascript).each do |field| -%>
+    this.<%= field.snake_case %> = options.<%= field.snake_case %> ?? DEFAULT_PARSER_OPTIONS.<%= field.snake_case %>
+  <%- end -%>
+  }
+}

data/templates/javascript/packages/core/src/visitor.ts.erb

@@ -47,7 +47,7 @@ export class Visitor implements IVisitor {
   <%- nodes.each do |node| -%>
   visit<%= node.name %>(node: <%= node.name %>): void {
     this.visitNode(node)
-    <%- if node.name.start_with?("ERB") -%>
+    <%- if node.erb_tag? -%>
     this.visitERBNode(node)
     <%- end -%>
     this.visitChildNodes(node)

data/templates/javascript/packages/node/extension/error_helpers.cpp.erb

@@ -42,11 +42,11 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::NodeField -%>
-  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= error.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::TokenField -%>
-  napi_value <%= field.name %> = CreateToken(env, <%= error.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = CreateToken(env, <%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::TokenTypeField -%>
@@ -68,7 +68,7 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::ArrayField -%>
-  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= error.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- else -%>

data/templates/javascript/packages/node/extension/nodes.cpp.erb

@@ -11,11 +11,11 @@ extern "C" {
 #include "../extension/libherb/include/lib/hb_array.h"
 }
 
-napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
+napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node, const parser_options_T* options);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array, const parser_options_T* options);
 
 <%- nodes.each do |node| -%>
-napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>) {
+napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>, const parser_options_T* options) {
   if (!<%= node.human %>) {
     napi_value null_value;
     napi_get_null(env, &null_value);
@@ -28,7 +28,12 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   napi_value type = CreateStringFromHbString(env, ast_node_type_to_string(&<%= node.human %>->base));
   napi_set_named_property(env, result, "type", type);
 
-  napi_value location = CreateLocation(env, <%= node.human %>->base.location);
+  napi_value location;
+  if (options->track_locations) {
+    location = CreateLocation(env, <%= node.human %>->base.location);
+  } else {
+    napi_get_null(env, &location);
+  }
   napi_set_named_property(env, result, "location", location);
 
   napi_value errors = ErrorsArrayFromCArray(env, <%= node.human %>->base.errors);
@@ -41,11 +46,11 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
-  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>, options);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::TokenField -%>
-  napi_value <%= field.name %> = CreateToken(env, <%= node.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = CreateToken(env, <%= node.human %>-><%= field.name %>, options);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::BooleanField -%>
@@ -54,7 +59,7 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::ArrayField -%>
-  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>, options);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::ElementSourceField -%>
@@ -63,7 +68,7 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
 
   <%- when Herb::Template::LocationField -%>
   napi_value <%= field.name %>;
-  if (<%= node.human %>-><%= field.name %> != NULL) {
+  if (options->track_locations && <%= node.human %>-><%= field.name %> != NULL) {
     <%= field.name %> = CreateLocation(env, *<%= node.human %>-><%= field.name %>);
   } else {
     napi_get_null(env, &<%= field.name %>);
@@ -119,7 +124,7 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
 }
 <%- end -%>
 
-napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array, const parser_options_T* options) {
   napi_value result;
   napi_create_array(env, &result);
 
@@ -129,7 +134,7 @@ napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
     for (size_t i = 0; i < hb_array_size(array); i++) {
       AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
       if (child_node) {
-        napi_value js_child = NodeFromCStruct(env, child_node);
+        napi_value js_child = NodeFromCStruct(env, child_node, options);
         napi_set_element(env, result, index++, js_child);
       }
     }
@@ -138,7 +143,7 @@ napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   return result;
 }
 
-napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node) {
+napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node, const parser_options_T* options) {
   if (!node) {
     napi_value null_value;
     napi_get_null(env, &null_value);
@@ -148,7 +153,7 @@ napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node) {
   switch (node->type) {
   <%- nodes.each do |node| -%>
     case <%= node.type %>:
-      return <%= node.human %>NodeFromCStruct(env, (<%= node.struct_type %>*) node);
+      return <%= node.human %>NodeFromCStruct(env, (<%= node.struct_type %>*) node, options);
       break;
   <%- end -%>
     default:

data/templates/javascript/packages/node/extension/nodes.h.erb

@@ -7,11 +7,11 @@ extern "C" {
 #include "../extension/libherb/include/herb.h"
 }
 
-napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
+napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node, const parser_options_T* options);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array, const parser_options_T* options);
 
 <%- nodes.each do |node| -%>
-napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>);
+napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>, const parser_options_T* options);
 <%- end -%>
 
 #endif

data/templates/javascript/packages/node/extension/parser_options_helpers.cpp.erb

@@ -0,0 +1,41 @@
+#include "parser_options_helpers.h"
+
+void herb_extract_parser_options(napi_env env, napi_value options, parser_options_T* parser_options) {
+  napi_valuetype valuetype;
+  napi_typeof(env, options, &valuetype);
+
+  if (valuetype != napi_object) { return; }
+<%- parser_options.extractable_fields_for(:javascript).each do |field| -%>
+
+  {
+    bool has_property = false;
+    napi_has_named_property(env, options, "<%= field.snake_case %>", &has_property);
+
+    if (has_property) {
+      napi_value property;
+      napi_get_named_property(env, options, "<%= field.snake_case %>", &property);
+
+<%- if field.boolean? -%>
+      bool value = false;
+      napi_get_value_bool(env, property, &value);
+      parser_options-><%= field.c_name %> = value;
+<%- elsif field.nullable? -%>
+      napi_valuetype property_type;
+      napi_typeof(env, property, &property_type);
+
+      if (property_type == napi_number) {
+        uint32_t value = 0;
+        napi_get_value_uint32(env, property, &value);
+        parser_options-><%= field.c_name %> = value;
+      } else {
+        parser_options-><%= field.c_name %> = <%= field.null_sentinel %>;
+      }
+<%- else -%>
+      uint32_t value = 0;
+      napi_get_value_uint32(env, property, &value);
+      parser_options-><%= field.c_name %> = value;
+<%- end -%>
+    }
+  }
+<%- end -%>
+}

data/templates/javascript/packages/node/extension/parser_options_helpers.h.erb

@@ -0,0 +1,12 @@
+#ifndef HERB_NODE_PARSER_OPTIONS_HELPERS_H
+#define HERB_NODE_PARSER_OPTIONS_HELPERS_H
+
+#include <node_api.h>
+
+extern "C" {
+#include "../extension/libherb/include/parser/parser_options.h"
+}
+
+void herb_extract_parser_options(napi_env env, napi_value options, parser_options_T* parser_options);
+
+#endif