@herb-tools/core 0.7.5 → 0.8.1

package/dist/types/ast-utils.d.ts

@@ -1,10 +1,15 @@
-import { Node, ERBContentNode, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLAttributeNameNode } from "./nodes.js";
+import { Node, ERBNode, ERBContentNode, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLAttributeNameNode } from "./nodes.js";
 import type { Location } from "./location.js";
 import type { Position } from "./position.js";
+export type ERBOutputNode = ERBNode & {
+    tag_opening: {
+        value: "<%=" | "<%==";
+    };
+};
 /**
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
  */
-export declare function isERBOutputNode(node: Node): node is ERBContentNode;
+export declare function isERBOutputNode(node: Node): node is ERBOutputNode;
 /**
  * Checks if a node is a non-output ERB node (control flow: <% %>)
  */

package/dist/types/didyoumean.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Ranked result with item and distance score.
+ */
+export interface RankedResult {
+    item: string;
+    score: number;
+}
+/**
+ * Finds the closest matching string from a list using Levenshtein distance.
+ * Performs case-insensitive comparison.
+ *
+ * @param input - The string to match against
+ * @param list - The list of candidate strings to search
+ * @param threshold - Maximum Levenshtein distance to consider a match. If undefined, returns the closest match regardless of distance.
+ * @returns The closest matching string from the list, or null if the list is empty or no match is within the threshold
+ *
+ * @example
+ * ```ts
+ * didyoumean('speling', ['spelling', 'writing', 'reading']) // Returns 'spelling'
+ * didyoumean('test', []) // Returns null
+ * didyoumean('speling', ['spelling', 'writing', 'reading'], 2) // Returns 'spelling' (distance: 1)
+ * didyoumean('xyz', ['spelling', 'writing', 'reading'], 2) // Returns null (all distances > 2)
+ * ```
+ */
+export declare function didyoumean(input: string, list: string[], threshold?: number): string | null;
+/**
+ * Returns all strings from a list ranked by their Levenshtein distance from the input string.
+ * Performs case-insensitive comparison. Results are sorted with closest matches first.
+ *
+ * @param input - The string to match against
+ * @param list - The list of candidate strings to rank
+ * @param threshold - Maximum Levenshtein distance to include in results. If undefined, returns all ranked results.
+ * @returns An array of ranked results with items and scores, or an empty array if the list is empty or no matches are within the threshold
+ *
+ * @example
+ * ```ts
+ * didyoumeanRanked('speling', ['spelling', 'writing', 'reading'])
+ * // Returns [{ item: 'spelling', score: 1 }, { item: 'reading', score: 5 }, { item: 'writing', score: 6 }]
+ *
+ * didyoumeanRanked('speling', ['spelling', 'writing', 'reading'], 2)
+ * // Returns [{ item: 'spelling', score: 1 }]
+ *
+ * didyoumeanRanked('test', []) // Returns []
+ * ```
+ */
+export declare function didyoumeanRanked(input: string, list: string[], threshold?: number): RankedResult[];

package/dist/types/errors.d.ts

@@ -1,7 +1,7 @@
 import { Location, SerializedLocation } from "./location.js";
 import { Token, SerializedToken } from "./token.js";
 import { Diagnostic, MonacoDiagnostic } from "./diagnostic.js";
-export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "QUOTES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR";
+export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "QUOTES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSINGERB_END_TAG_ERROR";
 export type SerializedErrorType = string;
 export interface SerializedHerbError {
     type: string;
@@ -228,4 +228,44 @@ export declare class RubyParseError extends HerbError {
     toMonacoDiagnostic(): MonacoDiagnostic;
     treeInspect(): string;
 }
+export interface SerializedERBControlFlowScopeError {
+    type: "ERB_CONTROL_FLOW_SCOPE_ERROR";
+    message: string;
+    location: SerializedLocation;
+    keyword: string;
+}
+export interface ERBControlFlowScopeErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    keyword: string;
+}
+export declare class ERBControlFlowScopeError extends HerbError {
+    readonly keyword: string;
+    static from(data: SerializedERBControlFlowScopeError): ERBControlFlowScopeError;
+    constructor(props: ERBControlFlowScopeErrorProps);
+    toJSON(): SerializedERBControlFlowScopeError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedMissingERBEndTagError {
+    type: "MISSINGERB_END_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    keyword: string;
+}
+export interface MissingERBEndTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    keyword: string;
+}
+export declare class MissingERBEndTagError extends HerbError {
+    readonly keyword: string;
+    static from(data: SerializedMissingERBEndTagError): MissingERBEndTagError;
+    constructor(props: MissingERBEndTagErrorProps);
+    toJSON(): SerializedMissingERBEndTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
 export declare function fromSerializedError(error: SerializedHerbError): HerbError;

package/dist/types/index.d.ts

@@ -1,12 +1,14 @@
 export * from "./ast-utils.js";
 export * from "./backend.js";
 export * from "./diagnostic.js";
+export * from "./didyoumean.js";
 export * from "./errors.js";
 export * from "./herb-backend.js";
+export * from "./levenshtein.js";
 export * from "./lex-result.js";
 export * from "./location.js";
-export * from "./nodes.js";
 export * from "./node-type-guards.js";
+export * from "./nodes.js";
 export * from "./parse-result.js";
 export * from "./parser-options.js";
 export * from "./position.js";

package/dist/types/levenshtein.d.ts

@@ -0,0 +1 @@
+export declare function levenshtein(a: string, b: string): number;

package/dist/types/location.d.ts

@@ -8,6 +8,8 @@ export declare class Location {
     readonly start: Position;
     readonly end: Position;
     static from(location: SerializedLocation): Location;
+    static from(line: number, column: number, endLine: number, endColumn: number): Location;
+    static get zero(): Location;
     constructor(start: Position, end: Position);
     toHash(): SerializedLocation;
     toJSON(): SerializedLocation;

package/dist/types/position.d.ts

@@ -6,6 +6,8 @@ export declare class Position {
     readonly line: number;
     readonly column: number;
     static from(position: SerializedPosition): Position;
+    static from(line: number, column: number): Position;
+    static get zero(): Position;
     constructor(line: number, column: number);
     toHash(): SerializedPosition;
     toJSON(): SerializedPosition;

package/dist/types/range.d.ts

@@ -3,6 +3,8 @@ export declare class Range {
     readonly start: number;
     readonly end: number;
     static from(range: SerializedRange): Range;
+    static from(start: number, end: number): Range;
+    static get zero(): Range;
     constructor(start: number, end: number);
     toArray(): SerializedRange;
     toJSON(): SerializedRange;

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@herb-tools/core",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "Core module exporting shared interfaces, AST node definitions, and common utilities for Herb",
-  "type": "module",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
   "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/core%60:%20",

package/src/ast-utils.ts

@@ -1,6 +1,7 @@
 import {
   Node,
   LiteralNode,
+  ERBNode,
   ERBContentNode,
   ERBIfNode,
   ERBUnlessNode,
@@ -30,11 +31,17 @@ import {
 import type { Location } from "./location.js"
 import type { Position } from "./position.js"
 
+export type ERBOutputNode = ERBNode & {
+  tag_opening: {
+    value: "<%=" | "<%=="
+  }
+}
+
 /**
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
  */
-export function isERBOutputNode(node: Node): node is ERBContentNode {
-  if (!isNode(node, ERBContentNode)) return false
+export function isERBOutputNode(node: Node): node is ERBOutputNode {
+  if (!isERBNode(node)) return false
   if (!node.tag_opening?.value) return false
 
   return ["<%=", "<%=="].includes(node.tag_opening?.value)

package/src/didyoumean.ts

@@ -0,0 +1,88 @@
+import { levenshtein } from "./levenshtein"
+
+/**
+ * Ranked result with item and distance score.
+ */
+export interface RankedResult {
+  item: string
+  score: number
+}
+
+/**
+ * Ranks a list of strings by their Levenshtein distance from the input string.
+ * Items are sorted in ascending order by distance, with closer matches first.
+ *
+ * @param input - The string to compare against
+ * @param list - The list of strings to rank
+ * @returns An array of objects containing the item and its distance score, sorted by score
+ */
+function rank(input: string, list: string[]): RankedResult[] {
+  return list.map(item => {
+    const score = levenshtein(input.toLowerCase(), item.toLowerCase())
+
+    return { item, score }
+  }).sort((a, b) => a.score - b.score)
+}
+
+/**
+ * Finds the closest matching string from a list using Levenshtein distance.
+ * Performs case-insensitive comparison.
+ *
+ * @param input - The string to match against
+ * @param list - The list of candidate strings to search
+ * @param threshold - Maximum Levenshtein distance to consider a match. If undefined, returns the closest match regardless of distance.
+ * @returns The closest matching string from the list, or null if the list is empty or no match is within the threshold
+ *
+ * @example
+ * ```ts
+ * didyoumean('speling', ['spelling', 'writing', 'reading']) // Returns 'spelling'
+ * didyoumean('test', []) // Returns null
+ * didyoumean('speling', ['spelling', 'writing', 'reading'], 2) // Returns 'spelling' (distance: 1)
+ * didyoumean('xyz', ['spelling', 'writing', 'reading'], 2) // Returns null (all distances > 2)
+ * ```
+ */
+export function didyoumean(input: string, list: string[], threshold?: number): string | null {
+  if (list.length === 0) return null
+
+  const scores = rank(input, list)
+
+  if (scores.length === 0) return null
+
+  const closest = scores[0]
+
+  if (threshold !== undefined && closest.score > threshold) return null
+
+  return closest.item
+}
+
+/**
+ * Returns all strings from a list ranked by their Levenshtein distance from the input string.
+ * Performs case-insensitive comparison. Results are sorted with closest matches first.
+ *
+ * @param input - The string to match against
+ * @param list - The list of candidate strings to rank
+ * @param threshold - Maximum Levenshtein distance to include in results. If undefined, returns all ranked results.
+ * @returns An array of ranked results with items and scores, or an empty array if the list is empty or no matches are within the threshold
+ *
+ * @example
+ * ```ts
+ * didyoumeanRanked('speling', ['spelling', 'writing', 'reading'])
+ * // Returns [{ item: 'spelling', score: 1 }, { item: 'reading', score: 5 }, { item: 'writing', score: 6 }]
+ *
+ * didyoumeanRanked('speling', ['spelling', 'writing', 'reading'], 2)
+ * // Returns [{ item: 'spelling', score: 1 }]
+ *
+ * didyoumeanRanked('test', []) // Returns []
+ * ```
+ */
+export function didyoumeanRanked(input: string, list: string[], threshold?: number): RankedResult[] {
+  if (list.length === 0) return []
+
+  const scores = rank(input, list)
+
+  if (threshold !== undefined) {
+    return scores.filter(result => result.score <= threshold)
+  }
+
+  return scores
+}

package/src/errors.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.5/templates/javascript/packages/core/src/errors.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.1/templates/javascript/packages/core/src/errors.ts.erb
 
 import { Location, SerializedLocation } from "./location.js"
 import { Token, SerializedToken } from "./token.js"
@@ -15,6 +15,8 @@ export type HerbErrorType =
   | "VOID_ELEMENT_CLOSING_TAG_ERROR"
   | "UNCLOSED_ELEMENT_ERROR"
   | "RUBY_PARSE_ERROR"
+  | "ERB_CONTROL_FLOW_SCOPE_ERROR"
+  | "MISSINGERB_END_TAG_ERROR"
 
 export type SerializedErrorType = string
 
@@ -681,6 +683,130 @@ export class RubyParseError extends HerbError {
   }
 }
 
+export interface SerializedERBControlFlowScopeError {
+  type: "ERB_CONTROL_FLOW_SCOPE_ERROR";
+  message: string;
+  location: SerializedLocation;
+  keyword: string;
+}
+
+export interface ERBControlFlowScopeErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  keyword: string;
+}
+
+export class ERBControlFlowScopeError extends HerbError {
+  readonly keyword: string;
+
+  static from(data: SerializedERBControlFlowScopeError): ERBControlFlowScopeError {
+    return new ERBControlFlowScopeError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      keyword: data.keyword,
+    })
+  }
+
+  constructor(props: ERBControlFlowScopeErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.keyword = props.keyword;
+  }
+
+  toJSON(): SerializedERBControlFlowScopeError {
+    return {
+      ...super.toJSON(),
+      type: "ERB_CONTROL_FLOW_SCOPE_ERROR",
+      keyword: this.keyword,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ ERBControlFlowScopeError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── keyword: ${JSON.stringify(this.keyword)}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedMissingERBEndTagError {
+  type: "MISSINGERB_END_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  keyword: string;
+}
+
+export interface MissingERBEndTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  keyword: string;
+}
+
+export class MissingERBEndTagError extends HerbError {
+  readonly keyword: string;
+
+  static from(data: SerializedMissingERBEndTagError): MissingERBEndTagError {
+    return new MissingERBEndTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      keyword: data.keyword,
+    })
+  }
+
+  constructor(props: MissingERBEndTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.keyword = props.keyword;
+  }
+
+  toJSON(): SerializedMissingERBEndTagError {
+    return {
+      ...super.toJSON(),
+      type: "MISSINGERB_END_TAG_ERROR",
+      keyword: this.keyword,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ MissingERBEndTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── keyword: ${JSON.stringify(this.keyword)}\n`;
+
+    return output;
+  }
+}
+
 
 export function fromSerializedError(error: SerializedHerbError): HerbError {
   switch (error.type) {
@@ -693,6 +819,8 @@ export function fromSerializedError(error: SerializedHerbError): HerbError {
     case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error as SerializedVoidElementClosingTagError);
     case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error as SerializedUnclosedElementError);
     case "RUBY_PARSE_ERROR": return RubyParseError.from(error as SerializedRubyParseError);
+    case "ERB_CONTROL_FLOW_SCOPE_ERROR": return ERBControlFlowScopeError.from(error as SerializedERBControlFlowScopeError);
+    case "MISSINGERB_END_TAG_ERROR": return MissingERBEndTagError.from(error as SerializedMissingERBEndTagError);
 
     default:
       throw new Error(`Unknown node type: ${error.type}`);

package/src/index.ts

@@ -1,12 +1,14 @@
 export * from "./ast-utils.js"
 export * from "./backend.js"
 export * from "./diagnostic.js"
+export * from "./didyoumean.js"
 export * from "./errors.js"
 export * from "./herb-backend.js"
+export * from "./levenshtein.js"
 export * from "./lex-result.js"
 export * from "./location.js"
-export * from "./nodes.js"
 export * from "./node-type-guards.js"
+export * from "./nodes.js"
 export * from "./parse-result.js"
 export * from "./parser-options.js"
 export * from "./position.js"

package/src/levenshtein.ts

@@ -0,0 +1,119 @@
+/*
+ * The following code is derived from the "js-levenshtein" repository,
+ * Copyright (c) 2017 Gustaf Andersson (https://github.com/gustf/js-levenshtein)
+ * Licensed under the MIT License (https://github.com/gustf/js-levenshtein/blob/master/LICENSE).
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * https://github.com/marcoroth/stimulus-lsp/blob/52268d4a4d06504dde6cb81f505a23b5db5d5759/server/src/levenshtein.ts
+ *
+ */
+
+export function levenshtein(a: string, b: string): number {
+  function _min(d0: any, d1: any, d2: any, bx: any, ay: any) {
+    return d0 < d1 || d2 < d1 ? (d0 > d2 ? d2 + 1 : d0 + 1) : bx === ay ? d1 : d1 + 1
+  }
+
+  if (a === b) {
+    return 0
+  }
+
+  if (a.length > b.length) {
+    const tmp = a
+    a = b
+    b = tmp
+  }
+
+  let la = a.length
+  let lb = b.length
+
+  while (la > 0 && a.charCodeAt(la - 1) === b.charCodeAt(lb - 1)) {
+    la--
+    lb--
+  }
+
+  let offset = 0
+
+  while (offset < la && a.charCodeAt(offset) === b.charCodeAt(offset)) {
+    offset++
+  }
+
+  la -= offset
+  lb -= offset
+
+  if (la === 0 || lb < 3) {
+    return lb
+  }
+
+  let x = 0
+  let y
+  let d0
+  let d1
+  let d2
+  let d3
+  let dd
+  let dy
+  let ay
+  let bx0
+  let bx1
+  let bx2
+  let bx3
+
+  const vector = []
+
+  for (y = 0; y < la; y++) {
+    vector.push(y + 1)
+    vector.push(a.charCodeAt(offset + y))
+  }
+
+  const len = vector.length - 1
+
+  for (; x < lb - 3; ) {
+    bx0 = b.charCodeAt(offset + (d0 = x))
+    bx1 = b.charCodeAt(offset + (d1 = x + 1))
+    bx2 = b.charCodeAt(offset + (d2 = x + 2))
+    bx3 = b.charCodeAt(offset + (d3 = x + 3))
+    dd = x += 4
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y]
+      ay = vector[y + 1]
+      d0 = _min(dy, d0, d1, bx0, ay)
+      d1 = _min(d0, d1, d2, bx1, ay)
+      d2 = _min(d1, d2, d3, bx2, ay)
+      dd = _min(d2, d3, dd, bx3, ay)
+      vector[y] = dd
+      d3 = d2
+      d2 = d1
+      d1 = d0
+      d0 = dy
+    }
+  }
+
+  for (; x < lb; ) {
+    bx0 = b.charCodeAt(offset + (d0 = x))
+    dd = ++x
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y]
+      vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1])
+      d0 = dy
+    }
+  }
+
+  return dd
+}

package/src/location.ts

@@ -10,11 +10,24 @@ export class Location {
   readonly start: Position
   readonly end: Position
 
-  static from(location: SerializedLocation) {
-    const start = Position.from(location.start)
-    const end = Position.from(location.end)
+  static from(location: SerializedLocation): Location
+  static from(line: number, column: number, endLine: number, endColumn: number): Location
+  static from(locationOrLine: SerializedLocation | number, column?: number, endLine?: number, endColumn?: number): Location {
+    if (typeof locationOrLine === "number") {
+      const start = Position.from(locationOrLine, column!)
+      const end = Position.from(endLine!, endColumn!)
 
-    return new Location(start, end)
+      return new Location(start, end)
+    } else {
+      const start = Position.from(locationOrLine.start)
+      const end = Position.from(locationOrLine.end)
+
+      return new Location(start, end)
+    }
+  }
+
+  static get zero() {
+    return new Location(Position.zero, Position.zero)
   }
 
   constructor(start: Position, end: Position) {

package/src/node-type-guards.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.5/templates/javascript/packages/core/src/node-type-guards.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.1/templates/javascript/packages/core/src/node-type-guards.ts.erb
 
 import type { Node, NodeType, ERBNode } from "./nodes.js"
 

package/src/nodes.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.5/templates/javascript/packages/core/src/nodes.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.1/templates/javascript/packages/core/src/nodes.ts.erb
 
 import { Location } from "./location.js"
 import { Token, SerializedToken } from "./token.js"

package/src/position.ts

@@ -7,8 +7,18 @@ export class Position {
   readonly line: number
   readonly column: number
 
-  static from(position: SerializedPosition) {
-    return new Position(position.line, position.column)
+  static from(position: SerializedPosition): Position
+  static from(line: number, column: number): Position
+  static from(positionOrLine: SerializedPosition | number, column?: number): Position {
+    if (typeof positionOrLine === "number") {
+      return new Position(positionOrLine, column!)
+    } else {
+      return new Position(positionOrLine.line, positionOrLine.column)
+    }
+  }
+
+  static get zero() {
+    return new Position(0, 0)
   }
 
   constructor(line: number, column: number) {

package/src/range.ts

@@ -4,8 +4,18 @@ export class Range {
   readonly start: number
   readonly end: number
 
-  static from(range: SerializedRange) {
-    return new Range(range[0], range[1])
+  static from(range: SerializedRange): Range
+  static from(start: number, end: number): Range
+  static from(rangeOrStart: SerializedRange | number, end?: number): Range {
+    if (typeof rangeOrStart === "number") {
+      return new Range(rangeOrStart, end!)
+    } else {
+      return new Range(rangeOrStart[0], rangeOrStart[1])
+    }
+  }
+
+  static get zero() {
+    return new Range(0, 0)
   }
 
   constructor(start: number, end: number) {