solid-tag-runtime 0.0.15 → 0.0.18

package/src/html/data-literal.js

@@ -0,0 +1,270 @@
+/**
+ * Parse a safe JSON5-style data literal without evaluating JavaScript.
+ *
+ * Supported conveniences intentionally cover declarative HTML data:
+ * - single/double quoted strings
+ * - unquoted object keys
+ * - line/block comments
+ * - trailing commas
+ * - arrays/objects
+ * - booleans/null/numbers
+ *
+ * Identifiers are accepted only as object keys or the literals true/false/null.
+ * Calls, property access, functions, constructors, variables, and expressions
+ * are rejected because this parser never executes JavaScript.
+ */
+export function parseHTMLDataLiteral(source) {
+  const input = String(source ?? "");
+  let index = 0;
+
+  const error = message => {
+    const position = index;
+    const context = input.slice(Math.max(0, position - 16), Math.min(input.length, position + 16));
+    const failure = new SyntaxError(`${message} at position ${position}${context ? ` near ${JSON.stringify(context)}` : ""}.`);
+    failure.position = position;
+    throw failure;
+  };
+
+  const peek = () => input[index];
+  const consume = expected => {
+    if (input[index] !== expected) error(`Expected ${JSON.stringify(expected)}`);
+    index += 1;
+  };
+
+  function skipSpaceAndComments() {
+    while (index < input.length) {
+      const char = input[index];
+      if (/\s/.test(char)) {
+        index += 1;
+        continue;
+      }
+      if (char === "/" && input[index + 1] === "/") {
+        index += 2;
+        while (index < input.length && input[index] !== "\n" && input[index] !== "\r") index += 1;
+        continue;
+      }
+      if (char === "/" && input[index + 1] === "*") {
+        index += 2;
+        const end = input.indexOf("*/", index);
+        if (end < 0) error("Unterminated block comment");
+        index = end + 2;
+        continue;
+      }
+      break;
+    }
+  }
+
+  function parseString() {
+    const quote = input[index++];
+    let result = "";
+    while (index < input.length) {
+      const char = input[index++];
+      if (char === quote) return result;
+      if (char === "\n" || char === "\r") error("Unterminated string literal");
+      if (char !== "\\") {
+        result += char;
+        continue;
+      }
+      if (index >= input.length) error("Unterminated escape sequence");
+      const escape = input[index++];
+      switch (escape) {
+        case "'": result += "'"; break;
+        case '"': result += '"'; break;
+        case "\\": result += "\\"; break;
+        case "/": result += "/"; break;
+        case "b": result += "\b"; break;
+        case "f": result += "\f"; break;
+        case "n": result += "\n"; break;
+        case "r": result += "\r"; break;
+        case "t": result += "\t"; break;
+        case "v": result += "\v"; break;
+        case "0": {
+          if (/[0-9]/.test(input[index] ?? "")) error("Legacy octal escapes are not supported");
+          result += "\0";
+          break;
+        }
+        case "x": {
+          const hex = input.slice(index, index + 2);
+          if (!/^[0-9a-fA-F]{2}$/.test(hex)) error("Invalid hexadecimal escape");
+          result += String.fromCharCode(Number.parseInt(hex, 16));
+          index += 2;
+          break;
+        }
+        case "u": {
+          if (input[index] === "{") {
+            index += 1;
+            const close = input.indexOf("}", index);
+            if (close < 0) error("Invalid Unicode escape");
+            const hex = input.slice(index, close);
+            if (!/^[0-9a-fA-F]{1,6}$/.test(hex)) error("Invalid Unicode escape");
+            result += String.fromCodePoint(Number.parseInt(hex, 16));
+            index = close + 1;
+          } else {
+            const hex = input.slice(index, index + 4);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex)) error("Invalid Unicode escape");
+            result += String.fromCharCode(Number.parseInt(hex, 16));
+            index += 4;
+          }
+          break;
+        }
+        case "\n": break;
+        case "\r":
+          if (input[index] === "\n") index += 1;
+          break;
+        default:
+          result += escape;
+      }
+    }
+    error("Unterminated string literal");
+  }
+
+  function parseIdentifier() {
+    const start = index;
+    if (!/[A-Za-z_$]/.test(input[index] ?? "")) error("Expected identifier");
+    index += 1;
+    while (/[A-Za-z0-9_$]/.test(input[index] ?? "")) index += 1;
+    return input.slice(start, index);
+  }
+
+  function parseNumber() {
+    const start = index;
+    if (input[index] === "+" || input[index] === "-") index += 1;
+
+    if (input[index] === "0" && /[xX]/.test(input[index + 1] ?? "")) {
+      index += 2;
+      const hexStart = index;
+      while (/[0-9a-fA-F]/.test(input[index] ?? "")) index += 1;
+      if (index === hexStart) error("Invalid hexadecimal number");
+      const raw = input.slice(start, index);
+      const sign = raw.startsWith("-") ? -1 : 1;
+      const normalized = raw.replace(/^[+-]?0[xX]/, "");
+      return sign * Number.parseInt(normalized, 16);
+    }
+
+    let digits = 0;
+    while (/[0-9]/.test(input[index] ?? "")) {
+      digits += 1;
+      index += 1;
+    }
+    if (input[index] === ".") {
+      index += 1;
+      while (/[0-9]/.test(input[index] ?? "")) {
+        digits += 1;
+        index += 1;
+      }
+    }
+    if (digits === 0) error("Invalid number");
+    if (/[eE]/.test(input[index] ?? "")) {
+      index += 1;
+      if (input[index] === "+" || input[index] === "-") index += 1;
+      const exponentStart = index;
+      while (/[0-9]/.test(input[index] ?? "")) index += 1;
+      if (index === exponentStart) error("Invalid exponent");
+    }
+    const raw = input.slice(start, index);
+    const value = Number(raw);
+    if (!Number.isFinite(value)) error("Invalid finite number");
+    return value;
+  }
+
+  function defineDataProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value,
+    });
+  }
+
+  function parseObject() {
+    consume("{");
+    skipSpaceAndComments();
+    const object = {};
+    if (peek() === "}") {
+      index += 1;
+      return object;
+    }
+    while (index < input.length) {
+      skipSpaceAndComments();
+      let key;
+      const char = peek();
+      if (char === "'" || char === '"') key = parseString();
+      else if (/[A-Za-z_$]/.test(char ?? "")) key = parseIdentifier();
+      else if (/[+\-.0-9]/.test(char ?? "")) key = String(parseNumber());
+      else error("Expected object key");
+
+      skipSpaceAndComments();
+      consume(":");
+      skipSpaceAndComments();
+      defineDataProperty(object, key, parseValue());
+      skipSpaceAndComments();
+      if (peek() === "}") {
+        index += 1;
+        return object;
+      }
+      consume(",");
+      skipSpaceAndComments();
+      if (peek() === "}") {
+        index += 1;
+        return object;
+      }
+    }
+    error("Unterminated object literal");
+  }
+
+  function parseArray() {
+    consume("[");
+    skipSpaceAndComments();
+    const array = [];
+    if (peek() === "]") {
+      index += 1;
+      return array;
+    }
+    while (index < input.length) {
+      array.push(parseValue());
+      skipSpaceAndComments();
+      if (peek() === "]") {
+        index += 1;
+        return array;
+      }
+      consume(",");
+      skipSpaceAndComments();
+      if (peek() === "]") {
+        index += 1;
+        return array;
+      }
+    }
+    error("Unterminated array literal");
+  }
+
+  function parseValue() {
+    skipSpaceAndComments();
+    const char = peek();
+    if (char === "{") return parseObject();
+    if (char === "[") return parseArray();
+    if (char === "'" || char === '"') return parseString();
+    if (/[+\-.0-9]/.test(char ?? "")) return parseNumber();
+    if (/[A-Za-z_$]/.test(char ?? "")) {
+      const identifier = parseIdentifier();
+      if (identifier === "true") return true;
+      if (identifier === "false") return false;
+      if (identifier === "null") return null;
+      error(`Unsupported identifier ${JSON.stringify(identifier)}; declarative values cannot execute JavaScript`);
+    }
+    error("Expected data literal");
+  }
+
+  skipSpaceAndComments();
+  const value = parseValue();
+  skipSpaceAndComments();
+  if (index !== input.length) error("Unexpected trailing input");
+  return value;
+}
+
+export function parseHTMLPropsObject(source) {
+  const value = parseHTMLDataLiteral(source);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError("The `props` attribute must contain a top-level object literal.");
+  }
+  return value;
+}