Convert src/compiler/utils/extract_svelte_ignore.ts to JavaScript

src/compiler/utils/error.js

@@ -34,6 +34,7 @@ class CompileError extends Error {
 	 * @type {string}
 	 */
 	frame = undefined;
+
 	toString() {
 		return `${this.message} (${this.start.line}:${this.start.column})\n${this.frame}`;
 	}

src/compiler/utils/extract_svelte_ignore.ts

@@ -1,70 +1,76 @@
-import { TemplateNode } from '../interfaces';
+import { flatten } from './flatten.js';
-import { flatten } from './flatten';
 import { regex_whitespace } from './patterns';
-import { INode } from '../compile/nodes/interfaces';
-
 const regex_svelte_ignore = /^\s*svelte-ignore\s+([\s\S]+)\s*$/m;
 
-export function extract_svelte_ignore(text: string): string[] {
+/**
-	const match = regex_svelte_ignore.exec(text);
+ * @param {string} text
-	return match
+ * @returns {string[]}
-		? match[1]
+ */
-				.split(regex_whitespace)
+export function extract_svelte_ignore(text) {
-				.map((x) => x.trim())
+    const match = regex_svelte_ignore.exec(text);
-				.filter(Boolean)
+    return match
-		: [];
+        ? match[1]
+            .split(regex_whitespace)
+            .map((x) => x.trim())
+            .filter(Boolean)
+        : [];
 }
 
-export function extract_svelte_ignore_from_comments<
+/**
-	Node extends { leadingComments?: Array<{ value: string }> }
+ * @param {Node} node
->(node: Node): string[] {
+ * @returns {string[]}
-	return flatten(
+ */
-		(node.leadingComments || []).map((comment) => extract_svelte_ignore(comment.value))
+export function extract_svelte_ignore_from_comments(node) {
-	);
+    return flatten((node.leadingComments || []).map((comment) => extract_svelte_ignore(comment.value)));
 }
 
-export function extract_ignores_above_position(
+/**
-	position: number,
+ * @param {number} position
-	template_nodes: TemplateNode[]
+ * @param {TemplateNode[]} template_nodes
-): string[] {
+ * @returns {string[]}
-	const previous_node_idx = template_nodes.findIndex((child) => child.end === position);
+ */
-	if (previous_node_idx === -1) {
+export function extract_ignores_above_position(position, template_nodes) {
-		return [];
+    const previous_node_idx = template_nodes.findIndex((child) => child.end === position);
-	}
+    if (previous_node_idx === -1) {
-
+        return [];
-	for (let i = previous_node_idx; i >= 0; i--) {
+    }
-		const node = template_nodes[i];
+    for (let i = previous_node_idx; i >= 0; i--) {
-		if (node.type !== 'Comment' && node.type !== 'Text') {
+        const node = template_nodes[i];
-			return [];
+        if (node.type !== 'Comment' && node.type !== 'Text') {
-		}
+            return [];
-		if (node.type === 'Comment') {
+        }
-			if (node.ignores.length) {
+        if (node.type === 'Comment') {
-				return node.ignores;
+            if (node.ignores.length) {
-			}
+                return node.ignores;
-		}
+            }
-	}
+        }
+    }
+    return [];
+}
 
-	return [];
+/**
+ * @param {INode} node
+ * @returns {string[]}
+ */
+export function extract_ignores_above_node(node) {
+    /**
+     * This utilizes the fact that node has a prev and a next attribute
+     * which means that it can find svelte-ignores along
+     * the nodes on the same level as itself who share the same parent.
+     */
+    let cur_node = node.prev;
+    while (cur_node) {
+        if (cur_node.type !== 'Comment' && cur_node.type !== 'Text') {
+            return [];
+        }
+        if (cur_node.type === 'Comment' && cur_node.ignores.length) {
+            return cur_node.ignores;
+        }
+        cur_node = cur_node.prev;
+    }
+    return [];
 }
 
-export function extract_ignores_above_node(node: INode): string[] {
-	/**
-	 * This utilizes the fact that node has a prev and a next attribute
-	 * which means that it can find svelte-ignores along
-	 * the nodes on the same level as itself who share the same parent.
-	 */
-	let cur_node = node.prev;
-	while (cur_node) {
-		if (cur_node.type !== 'Comment' && cur_node.type !== 'Text') {
-			return [];
-		}
 
-		if (cur_node.type === 'Comment' && cur_node.ignores.length) {
-			return cur_node.ignores;
-		}
 
-		cur_node = cur_node.prev;
-	}
 
-	return [];
-}