samengine 1.6.4

package/dist/types/vector3d.js

@@ -0,0 +1,86 @@
+// 3d Vector
+import { clamp, lerp, map } from "../utils/math.js";
+// Function to create an Object of Type Vector3D
+export function makeVector3d(x, y, z) {
+    return {
+        x: x,
+        y: y,
+        z: z
+    };
+}
+// Function to add 2 Vectors together
+export function add3d(vector1, vector2) {
+    return {
+        x: vector1.x + vector2.x,
+        y: vector1.y + vector2.y,
+        z: vector1.z + vector2.z,
+    };
+}
+// Function to subtract 2 Vectors from each other
+export function subtract3d(vector1, vector2) {
+    return {
+        x: vector1.x - vector2.x,
+        y: vector1.y - vector2.y,
+        z: vector1.z - vector2.z,
+    };
+}
+// Function to get the length from an Vector
+export function length3d(vector) {
+    let produkt = vector.x * vector.x + vector.y * vector.y + vector.z * vector.z;
+    let root = Math.sqrt(produkt);
+    return root;
+}
+// Function to normalize a Vector 2d
+export function normalize3d(vector) {
+    // Check if the Vector is zero because then you dont need to
+    // calculate sth
+    if (vector.x == 0 && vector.y == 0 && vector.z) {
+        return vector;
+    }
+    let root = length3d(vector);
+    vector.x = vector.x / root;
+    vector.y = vector.y / root;
+    vector.z = vector.z / root;
+    return vector;
+}
+// Function to make scalar produkt from an Vector
+export function dot3d(v1, v2) {
+    return (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z);
+}
+// Function to calculate the cross produkt
+export function crossprodukt3d(v1, v2) {
+    return {
+        x: (v1.y * v2.z - v1.z * v2.y),
+        y: (v1.z * v2.x - v1.x * v2.z),
+        z: (v1.x * v2.y - v1.y * v2.x),
+    };
+}
+// Calculate the Distance between 2 Vectors
+export function distance3d(v1, v2) {
+    let tmp = subtract3d(v1, v2);
+    return length3d(tmp);
+}
+// Function to clamp a Vector 3d
+export function clamp3d(vector, min, max) {
+    return {
+        x: clamp(vector.x, min.x, max.x),
+        y: clamp(vector.y, min.y, max.y),
+        z: clamp(vector.y, min.y, max.y),
+    };
+}
+// Lerp for a 3d Vector
+export function lerp3d(start, end, t) {
+    return {
+        x: lerp(start.x, end.x, t.x),
+        y: lerp(start.y, end.y, t.y),
+        z: lerp(start.y, end.y, t.y),
+    };
+}
+// Map Function for a 3d Vector
+export function map3d(value, inMin, inMax, outMin, outMax) {
+    return {
+        x: map(value.x, inMin.x, inMax.x, outMin.x, outMax.x),
+        y: map(value.y, inMin.y, inMax.y, outMin.y, outMax.y),
+        z: map(value.z, inMin.z, inMax.z, outMin.z, outMax.z),
+    };
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { clamp, lerp, map } from "./math.js";
+export { parse as parseMarkdown, parseToDocument as parseMarkdownToDocument, exportcss as exportMarkdownCSS } from "./markdown.js";
+export type { JSONValue } from "./jsonc-parser.js";
+export { parseJSONC } from "./jsonc-parser.js";

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+// Utils Package
+// Math Utilities
+export { clamp, lerp, map } from "./math.js";
+// Markdown Parser
+export { parse as parseMarkdown, parseToDocument as parseMarkdownToDocument, exportcss as exportMarkdownCSS } from "./markdown.js";
+export { parseJSONC } from "./jsonc-parser.js";

package/dist/utils/jsonc-parser.d.ts

@@ -0,0 +1,4 @@
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export declare function parseJSONC(input: string): JSONValue;

package/dist/utils/jsonc-parser.js

@@ -0,0 +1,166 @@
+// jsonc-parser.ts
+// JSON with comments (// and /* */) parser in TypeScript
+export function parseJSONC(input) {
+    let i = 0;
+    function error(msg) {
+        throw new SyntaxError(`${msg} at position ${i}`);
+    }
+    function peek(offset = 0) {
+        return input[i + offset];
+    }
+    function consume() {
+        return input[i++];
+    }
+    function skipWhitespaceAndComments() {
+        while (i < input.length) {
+            // whitespace
+            if (/\s/.test(peek())) {
+                i++;
+                continue;
+            }
+            // line comment //
+            if (peek() === '/' && peek(1) === '/') {
+                i += 2;
+                while (i < input.length && peek() !== '\n')
+                    i++;
+                continue;
+            }
+            // block comment /* */
+            if (peek() === '/' && peek(1) === '*') {
+                i += 2;
+                while (i < input.length && !(peek() === '*' && peek(1) === '/')) {
+                    i++;
+                }
+                if (i >= input.length)
+                    error("Unterminated block comment");
+                i += 2;
+                continue;
+            }
+            break;
+        }
+    }
+    function parseValue() {
+        skipWhitespaceAndComments();
+        const ch = peek();
+        if (ch === '"')
+            return parseString();
+        if (ch === '{')
+            return parseObject();
+        if (ch === '[')
+            return parseArray();
+        if (ch === '-' || /[0-9]/.test(ch))
+            return parseNumber();
+        if (input.startsWith("true", i)) {
+            i += 4;
+            return true;
+        }
+        if (input.startsWith("false", i)) {
+            i += 5;
+            return false;
+        }
+        if (input.startsWith("null", i)) {
+            i += 4;
+            return null;
+        }
+        error("Unexpected token");
+    }
+    function parseString() {
+        consume(); // "
+        let result = "";
+        while (i < input.length) {
+            const ch = consume();
+            if (ch === '"')
+                return result;
+            if (ch === '\\') {
+                const next = consume();
+                if (next === 'n')
+                    result += '\n';
+                else if (next === 't')
+                    result += '\t';
+                else if (next === 'r')
+                    result += '\r';
+                else
+                    result += next;
+            }
+            else {
+                result += ch;
+            }
+        }
+        error("Unterminated string");
+    }
+    function parseNumber() {
+        let num = "";
+        while (/[-+0-9.eE]/.test(peek())) {
+            num += consume();
+        }
+        const value = Number(num);
+        if (Number.isNaN(value))
+            error("Invalid number");
+        return value;
+    }
+    function parseArray() {
+        consume(); // [
+        const arr = [];
+        skipWhitespaceAndComments();
+        if (peek() === ']') {
+            consume();
+            return arr;
+        }
+        while (true) {
+            arr.push(parseValue());
+            skipWhitespaceAndComments();
+            const ch = consume();
+            if (ch === ']')
+                break;
+            if (ch !== ',')
+                error("Expected ',' or ']'");
+            skipWhitespaceAndComments();
+            if (peek() === ']') {
+                consume();
+                break;
+            }
+        }
+        return arr;
+    }
+    function parseObject() {
+        consume(); // {
+        const obj = {};
+        skipWhitespaceAndComments();
+        if (peek() === '}') {
+            consume();
+            return obj;
+        }
+        while (true) {
+            skipWhitespaceAndComments();
+            const key = parseKey();
+            skipWhitespaceAndComments();
+            if (consume() !== ':')
+                error("Expected ':'");
+            const value = parseValue();
+            obj[key] = value;
+            skipWhitespaceAndComments();
+            const ch = consume();
+            if (ch === '}')
+                break;
+            if (ch !== ',')
+                error("Expected ',' or '}'");
+            skipWhitespaceAndComments();
+            if (peek() === '}') {
+                consume();
+                break;
+            }
+        }
+        return obj;
+    }
+    function parseKey() {
+        skipWhitespaceAndComments();
+        if (peek() === '"')
+            return parseString();
+        error("Keys must be strings in JSONC");
+    }
+    const result = parseValue();
+    skipWhitespaceAndComments();
+    if (i < input.length)
+        error("Unexpected trailing input");
+    return result;
+}

package/dist/utils/markdown.d.ts

@@ -0,0 +1,41 @@
+/**
+ * markdown-parser.ts
+ * Ein vollständiger Markdown → HTML Parser in TypeScript.
+ * Unterstützt: Überschriften, Absätze, Fett/Kursiv/Durchgestrichen,
+ * Inline-Code, Code-Blöcke (mit Sprach-Tag), Blockquotes (verschachtelt),
+ * geordnete & ungeordnete Listen (verschachtelt), Aufgabenlisten,
+ * horizontale Linien, Links, Bilder, Tabellen, Fußnoten, HTML-Entities.
+ */
+interface ParseOptions {
+    /** Fügt target="_blank" rel="noopener noreferrer" zu externen Links hinzu */
+    externalLinks?: boolean;
+    /** Bricht einfache Zeilenumbrüche in <br> um */
+    breaks?: boolean;
+    /** Gibt typographische Anführungszeichen zurück (Smartquotes) */
+    smartypants?: boolean;
+    /** Sanitisiert rohes HTML im Quelltext */
+    sanitize?: boolean;
+}
+/**
+ * Konvertiert Markdown-Text in HTML.
+ *
+ * @param markdown  Eingabe-Markdown
+ * @param options   Optionale Parser-Einstellungen
+ * @returns         Gerendertes HTML
+ *
+ * @example
+ * ```ts
+ * import { parse } from "./markdown-parser";
+ * const html = parse("# Hallo Welt\n\nDas ist **Markdown**.");
+ * ```
+ */
+export declare function parse(markdown: string, options?: ParseOptions): string;
+/**
+ * Gibt ein vollständiges HTML-Dokument zurück (optional mit eigenem CSS).
+ */
+export declare function parseToDocument(markdown: string, options?: ParseOptions & {
+    title?: string;
+    css?: string;
+}): string;
+export declare function exportcss(): string;
+export {};