jpsx 0.1.16

package/dist/api/benchmark.js

@@ -0,0 +1,147 @@
+import { compile } from "./index.js";
+/**
+ * Benchmark compilation performance
+ *
+ * @param source - JPS source code to compile
+ * @param options - Compilation options
+ * @param iterations - Number of iterations (default: 100)
+ * @returns Benchmark results
+ *
+ * @example
+ * ```typescript
+ * const result = benchmark('print("Hello")', {}, 1000);
+ * console.log(`Average: ${result.averageTime}ms`);
+ * console.log(`Throughput: ${result.throughput} ops/sec`);
+ * ```
+ */
+export function benchmark(source, options = {}, iterations = 100) {
+    const times = [];
+    // Warmup
+    for (let i = 0; i < 10; i++) {
+        compile(source, options);
+    }
+    // Actual benchmark
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        compile(source, options);
+        const end = performance.now();
+        times.push(end - start);
+    }
+    const totalTime = times.reduce((a, b) => a + b, 0);
+    const averageTime = totalTime / iterations;
+    const minTime = Math.min(...times);
+    const maxTime = Math.max(...times);
+    const throughput = 1000 / averageTime; // ops per second
+    return {
+        totalTime,
+        averageTime,
+        minTime,
+        maxTime,
+        iterations,
+        throughput
+    };
+}
+/**
+ * Compare performance across different options
+ *
+ * @param source - JPS source code
+ * @param optionsArray - Array of options to compare
+ * @param iterations - Number of iterations per test
+ * @returns Array of benchmark results
+ *
+ * @example
+ * ```typescript
+ * const results = comparePerformance(
+ *   'print("test")',
+ *   [
+ *     { format: 'esm', runtimeMode: 'inline' },
+ *     { format: 'esm', runtimeMode: 'external' },
+ *     { format: 'iife', runtimeMode: 'inline' }
+ *   ]
+ * );
+ * ```
+ */
+export function comparePerformance(source, optionsArray, iterations = 100) {
+    return optionsArray.map(options => ({
+        options,
+        result: benchmark(source, options, iterations)
+    }));
+}
+/**
+ * Profile compilation stages
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @returns Timing for each compilation stage
+ *
+ * @example
+ * ```typescript
+ * const profile = profileCompilation('def foo(): return 42');
+ * console.log(profile);
+ * // {
+ * //   tokenize: 0.5ms,
+ * //   parse: 1.2ms,
+ * //   transform: 0.3ms,
+ * //   generate: 0.8ms,
+ * //   total: 2.8ms
+ * // }
+ * ```
+ */
+export function profileCompilation(source, options = {}) {
+    const profile = {};
+    const totalStart = performance.now();
+    // Tokenize
+    const tokenizeStart = performance.now();
+    const { tokenize } = require("../lexer/tokenizer.js");
+    const tokens = tokenize(source);
+    profile.tokenize = performance.now() - tokenizeStart;
+    // Parse
+    const parseStart = performance.now();
+    const { parse } = require("../parser/parser.js");
+    const ast = parse(tokens);
+    profile.parse = performance.now() - parseStart;
+    // Transform
+    const transformStart = performance.now();
+    const { transform } = require("../transformer/transformer.js");
+    const transformed = transform(ast);
+    profile.transform = performance.now() - transformStart;
+    // Generate
+    const generateStart = performance.now();
+    const { generate } = require("../generator/generator.js");
+    generate(transformed);
+    profile.generate = performance.now() - generateStart;
+    profile.total = performance.now() - totalStart;
+    return profile;
+}
+/**
+ * Memory usage profiling
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @returns Memory usage information (if available)
+ */
+export function profileMemory(source, options = {}) {
+    if (typeof performance.memory === 'undefined') {
+        console.warn('Memory profiling not available in this environment');
+        return null;
+    }
+    const memory = performance.memory;
+    const before = memory.usedJSHeapSize;
+    compile(source, options);
+    const after = memory.usedJSHeapSize;
+    const delta = after - before;
+    return { before, after, delta };
+}
+/**
+ * Format benchmark results for display
+ */
+export function formatBenchmarkResult(result) {
+    return [
+        `Benchmark Results (${result.iterations} iterations):`,
+        `  Average: ${result.averageTime.toFixed(3)}ms`,
+        `  Min: ${result.minTime.toFixed(3)}ms`,
+        `  Max: ${result.maxTime.toFixed(3)}ms`,
+        `  Total: ${result.totalTime.toFixed(3)}ms`,
+        `  Throughput: ${result.throughput.toFixed(2)} ops/sec`
+    ].join('\n');
+}

package/dist/api/index.d.ts

@@ -0,0 +1,88 @@
+import { tokenize } from "../lexer/tokenizer.js";
+export * from "./advanced.js";
+export { tokenize };
+export type OutputFormat = "esm" | "cjs" | "iife" | "umd";
+export type RuntimeMode = "inline" | "external" | "cdn" | "none";
+export interface CompileOptions {
+    /**
+     * Output format for the generated code
+     * - esm: ES Module (default, for modern bundlers and frameworks)
+     * - cjs: CommonJS (for Node.js)
+     * - iife: Immediately Invoked Function Expression (for direct browser use)
+     * - umd: Universal Module Definition (works everywhere)
+     */
+    format?: OutputFormat;
+    /**
+     * How to handle the runtime library
+     * - inline: Include runtime code directly in output
+     * - external: Import from external file (default)
+     * - cdn: Import from CDN (for browser environments)
+     * - none: Don't include runtime (use when already loaded)
+     */
+    runtimeMode?: RuntimeMode;
+    /**
+     * CDN URL for runtime (only used when runtimeMode is 'cdn')
+     */
+    cdnUrl?: string;
+    /**
+     * Module name for UMD/IIFE formats
+     */
+    moduleName?: string;
+    /**
+     * Include source map
+     */
+    sourceMap?: boolean;
+    /**
+     * Standalone mode - bundles everything without external dependencies
+     */
+    standalone?: boolean;
+}
+export interface CompileResult {
+    /**
+     * Generated JavaScript code
+     */
+    code: string;
+    /**
+     * Source map (if enabled)
+     */
+    map?: string;
+    /**
+     * Runtime code (if inline mode)
+     */
+    runtime?: string;
+    /**
+     * AST for debugging
+     */
+    ast?: any;
+}
+/**
+ * Compile JPS source code to JavaScript
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @returns Compiled JavaScript code and metadata
+ *
+ * @example
+ * ```typescript
+ * // For React/Vue/Svelte with bundlers
+ * const result = compile(source, { format: 'esm', runtimeMode: 'external' });
+ *
+ * // For direct browser use
+ * const result = compile(source, { format: 'iife', runtimeMode: 'inline', moduleName: 'MyApp' });
+ *
+ * // For CDN usage
+ * const result = compile(source, { format: 'esm', runtimeMode: 'cdn' });
+ * ```
+ *
+ * @throws {CompilationError} When compilation fails with syntax or semantic errors
+ */
+export declare function compile(source: string, options?: CompileOptions): CompileResult;
+/**
+ * Compile JPS code and return only JavaScript (simplified API)
+ */
+export declare function compileToJS(source: string, options?: CompileOptions): string;
+/**
+ * Get the runtime library code
+ */
+export declare function getRuntime(): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMjD,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,CAAC;AAEpB,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IAEtB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,GAAG,CAAC,EAAE,GAAG,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,aAAa,CAmCnF;AAmND;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAE5E;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC"}

package/dist/api/index.js

@@ -0,0 +1,304 @@
+import { tokenize } from "../lexer/tokenizer.js";
+import { parse } from "../parser/parser.js";
+import { transform } from "../transformer/transformer.js";
+import { generate } from "../generator/generator.js";
+// Re-export advanced features
+export * from "./advanced.js";
+export { tokenize };
+/**
+ * Compile JPS source code to JavaScript
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @returns Compiled JavaScript code and metadata
+ *
+ * @example
+ * ```typescript
+ * // For React/Vue/Svelte with bundlers
+ * const result = compile(source, { format: 'esm', runtimeMode: 'external' });
+ *
+ * // For direct browser use
+ * const result = compile(source, { format: 'iife', runtimeMode: 'inline', moduleName: 'MyApp' });
+ *
+ * // For CDN usage
+ * const result = compile(source, { format: 'esm', runtimeMode: 'cdn' });
+ * ```
+ *
+ * @throws {CompilationError} When compilation fails with syntax or semantic errors
+ */
+export function compile(source, options = {}) {
+    const { format = "esm", runtimeMode = "external", cdnUrl = "https://cdn.jsdelivr.net/npm/jps@latest/dist/runtime/index.js", moduleName = "JPSModule", sourceMap = false, standalone = false } = options;
+    try {
+        // Validate options
+        validateOptions({ format, runtimeMode, cdnUrl, moduleName, sourceMap, standalone });
+        // Tokenize and parse
+        const tokens = tokenize(source);
+        const ast = parse(tokens);
+        const transformed = transform(ast);
+        // Generate base code
+        let code = generate(transformed);
+        // Handle different output formats and runtime modes
+        code = formatOutput(code, { format, runtimeMode, cdnUrl, moduleName, standalone });
+        const result = {
+            code,
+            ast: sourceMap ? ast : undefined
+        };
+        return result;
+    }
+    catch (error) {
+        // Enhance error messages
+        throw createCompilationError(error, source);
+    }
+}
+function formatOutput(code, options) {
+    const { format, runtimeMode, cdnUrl, moduleName, standalone } = options;
+    // Extract runtime import and code
+    const runtimeImportMatch = code.match(/import\s+{[^}]+}\s+from\s+"[^"]+";?\n*/);
+    const runtimeImport = runtimeImportMatch ? runtimeImportMatch[0] : "";
+    const codeWithoutImport = code.replace(runtimeImportMatch?.[0] || "", "");
+    let output = "";
+    switch (format) {
+        case "esm":
+            output = formatESM(runtimeImport, codeWithoutImport, runtimeMode, cdnUrl);
+            break;
+        case "cjs":
+            output = formatCJS(runtimeImport, codeWithoutImport, runtimeMode);
+            break;
+        case "iife":
+            output = formatIIFE(runtimeImport, codeWithoutImport, runtimeMode, moduleName, cdnUrl);
+            break;
+        case "umd":
+            output = formatUMD(runtimeImport, codeWithoutImport, runtimeMode, moduleName);
+            break;
+    }
+    return output;
+}
+function formatESM(runtimeImport, code, mode, cdnUrl) {
+    switch (mode) {
+        case "external":
+            return runtimeImport.replace("./jps_runtime.js", "./jps_runtime.js") + code;
+        case "cdn":
+            return runtimeImport.replace(/from\s+"[^"]+";/, `from "${cdnUrl}";`) + code;
+        case "inline":
+            // Will be handled by bundling runtime inline
+            return `${getInlineRuntime()}\n\n${code}`;
+        case "none":
+            return code;
+        default:
+            return runtimeImport + code;
+    }
+}
+function formatCJS(runtimeImport, code, mode) {
+    // Extract imported functions
+    const match = runtimeImport.match(/import\s+{([^}]+)}/);
+    const imports = match ? match[1].trim() : "";
+    const cjsImport = mode === "none"
+        ? ""
+        : `const { ${imports} } = require("./jps_runtime.js");\n\n`;
+    const cjsCode = code
+        .replace(/export\s+/g, "module.exports.")
+        .replace(/import\s+/g, "const ");
+    return cjsImport + cjsCode;
+}
+function formatIIFE(runtimeImport, code, mode, moduleName, cdnUrl) {
+    const match = runtimeImport.match(/import\s+{([^}]+)}/);
+    const imports = match ? match[1].split(",").map(s => s.trim()) : [];
+    if (mode === "inline") {
+        return `
+(function(global) {
+  ${getInlineRuntime()}
+
+  ${code.replace(/export\s+/g, "")}
+
+  global.${moduleName} = { ${imports.join(", ")} };
+})(typeof window !== "undefined" ? window : global);
+    `.trim();
+    }
+    return `
+(function(global) {
+  // Import runtime from CDN or external file
+  // For browsers: <script src="${cdnUrl}"></script> should be loaded first
+
+  ${code.replace(/export\s+/g, "")}
+
+  global.${moduleName} = { ${imports.join(", ")} };
+})(typeof window !== "undefined" ? window : global);
+  `.trim();
+}
+function formatUMD(runtimeImport, code, mode, moduleName) {
+    const match = runtimeImport.match(/import\s+{([^}]+)}/);
+    const imports = match ? match[1].split(",").map(s => s.trim()) : [];
+    return `
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD
+    define(['jps_runtime'], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    // CommonJS
+    module.exports = factory(require('./jps_runtime'));
+  } else {
+    // Browser globals
+    root.${moduleName} = factory(root.JPSRuntime);
+  }
+}(typeof self !== 'undefined' ? self : this, function (runtime) {
+  const { ${imports.join(", ")} } = runtime;
+
+  ${code.replace(/export\s+/g, "")}
+
+  return { ${imports.join(", ")} };
+}));
+  `.trim();
+}
+function getInlineRuntime() {
+    // Inline runtime functions
+    return `
+// JPS Runtime (inline)
+function print(...args) {
+  console.log(...args.map(arg =>
+    typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
+  ));
+}
+
+function len(obj) {
+  if (Array.isArray(obj) || typeof obj === 'string') return obj.length;
+  if (typeof obj === 'object') return Object.keys(obj).length;
+  return 0;
+}
+
+function range(...args) {
+  let start = 0, stop, step = 1;
+  if (args.length === 1) stop = args[0];
+  else if (args.length === 2) [start, stop] = args;
+  else [start, stop, step] = args;
+  const result = [];
+  for (let i = start; i < stop; i += step) result.push(i);
+  return result;
+}
+
+function sum(iterable) {
+  return Array.from(iterable).reduce((a, b) => a + b, 0);
+}
+
+function min(...args) {
+  const arr = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  return Math.min(...arr);
+}
+
+function max(...args) {
+  const arr = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  return Math.max(...arr);
+}
+
+function sorted(iterable, reverse = false) {
+  const arr = Array.from(iterable).sort((a, b) => a > b ? 1 : -1);
+  return reverse ? arr.reverse() : arr;
+}
+
+function str(val) {
+  return String(val);
+}
+
+function int(val) {
+  return parseInt(val, 10);
+}
+
+function float(val) {
+  return parseFloat(val);
+}
+
+function map(fn, iterable) {
+  return Array.from(iterable).map(fn);
+}
+
+function filter(fn, iterable) {
+  return Array.from(iterable).filter(fn);
+}
+
+function list(iterable) {
+  return Array.from(iterable);
+}
+
+function __in__(item, container) {
+    if (Array.isArray(container) || typeof container === "string") {
+        return container.includes(item);
+    }
+    if (container instanceof Set) {
+        return container.has(item);
+    }
+    if (container && typeof container === "object") {
+        return item in container;
+    }
+    return false;
+}
+
+if (!String.prototype.join) {
+  String.prototype.join = function(arr) {
+    return arr.join(this);
+  };
+}
+
+
+  `.trim();
+}
+/**
+ * Compile JPS code and return only JavaScript (simplified API)
+ */
+export function compileToJS(source, options) {
+    return compile(source, options).code;
+}
+/**
+ * Get the runtime library code
+ */
+export function getRuntime() {
+    return getInlineRuntime();
+}
+/**
+ * Validate compilation options
+ */
+function validateOptions(options) {
+    const validFormats = ['esm', 'cjs', 'iife', 'umd'];
+    const validRuntimeModes = ['inline', 'external', 'cdn', 'none'];
+    if (!validFormats.includes(options.format)) {
+        throw new Error(`Invalid output format: "${options.format}". Valid options are: ${validFormats.join(', ')}`);
+    }
+    if (!validRuntimeModes.includes(options.runtimeMode)) {
+        throw new Error(`Invalid runtime mode: "${options.runtimeMode}". Valid options are: ${validRuntimeModes.join(', ')}`);
+    }
+    if (options.runtimeMode === 'cdn' && !options.cdnUrl) {
+        throw new Error('CDN URL must be provided when using runtimeMode: "cdn"');
+    }
+    if ((options.format === 'iife' || options.format === 'umd') && !options.moduleName) {
+        console.warn(`Warning: No module name specified for ${options.format} format. Using default: "JPSModule"`);
+    }
+}
+/**
+ * Create enhanced compilation error with better messages
+ */
+function createCompilationError(error, source) {
+    if (error.token) {
+        // Syntax error from parser
+        const { line, col, value } = error.token;
+        const lines = source.split('\n');
+        const errorLine = lines[line - 1] || '';
+        const message = [
+            `Syntax Error at line ${line}, column ${col}:`,
+            `  Unexpected token: "${value}"`,
+            '',
+            `  ${line} | ${errorLine}`,
+            `  ${' '.repeat(String(line).length)} | ${' '.repeat(col - 1)}^`,
+            '',
+            'Check your JPS syntax and try again.'
+        ].join('\n');
+        const enhancedError = new Error(message);
+        enhancedError.token = error.token;
+        enhancedError.line = line;
+        enhancedError.column = col;
+        return enhancedError;
+    }
+    if (error.message) {
+        // General error with message
+        return new Error(`Compilation Error: ${error.message}`);
+    }
+    // Unknown error
+    return new Error(`Compilation Error: ${String(error)}`);
+}

package/dist/ast/types.d.ts

@@ -0,0 +1,141 @@
+export type Program = {
+    type: "Program";
+    body: Statement[];
+};
+export type Statement = FunctionDeclaration | ForStatement | WhileStatement | IfStatement | ExpressionStatement | ReturnStatement | ClassDeclaration | TryStatement | ImportDeclaration | ExportDeclaration;
+export type ImportDeclaration = {
+    type: "ImportDeclaration";
+    source: string;
+    specifiers: {
+        local: string;
+        imported: string;
+    }[];
+};
+export type ExportDeclaration = {
+    type: "ExportDeclaration";
+    declaration: Statement;
+};
+export type FunctionDeclaration = {
+    type: "FunctionDeclaration";
+    name: string;
+    params: string[];
+    body: Statement[];
+};
+export type ReturnStatement = {
+    type: "ReturnStatement";
+    argument: Expression | null;
+};
+export type ClassDeclaration = {
+    type: "ClassDeclaration";
+    name: string;
+    superClass: string | null;
+    body: Statement[];
+};
+export type TryStatement = {
+    type: "TryStatement";
+    block: Statement[];
+    handler: Statement[];
+};
+export type ForStatement = {
+    type: "ForStatement";
+    iterator: string;
+    start?: Expression;
+    end?: Expression;
+    collection?: Expression;
+    body: Statement[];
+};
+export type IfStatement = {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement[];
+    alternate: Statement[] | null;
+};
+export type ExpressionStatement = {
+    type: "ExpressionStatement";
+    expression: Expression;
+};
+export type Expression = Identifier | StringLiteral | FStringLiteral | NumberLiteral | BooleanLiteral | ArrayLiteral | ObjectLiteral | BinaryExpression | UnaryExpression | ConditionalExpression | CallExpression | ListComprehension | MemberExpression | LambdaExpression | NewExpression;
+export type LambdaExpression = {
+    type: "LambdaExpression";
+    params: string[];
+    body: Expression;
+};
+export type MemberExpression = {
+    type: "MemberExpression";
+    object: Expression;
+    property: Expression | Identifier;
+    computed: boolean;
+};
+export type Identifier = {
+    type: "Identifier";
+    name: string;
+};
+export type ListComprehension = {
+    type: "ListComprehension";
+    expression: Expression;
+    iterator: string;
+    start?: Expression;
+    end?: Expression;
+    collection?: Expression;
+    test?: Expression;
+};
+export type CallExpression = {
+    type: "CallExpression";
+    callee: Expression;
+    args: Expression[];
+};
+export type NewExpression = {
+    type: "NewExpression";
+    callee: Expression;
+    args: Expression[];
+};
+export type StringLiteral = {
+    type: "StringLiteral";
+    value: string;
+};
+export type FStringLiteral = {
+    type: "FStringLiteral";
+    value: string;
+};
+export type NumberLiteral = {
+    type: "NumberLiteral";
+    value: number;
+};
+export type BinaryExpression = {
+    type: "BinaryExpression";
+    operator: string;
+    left: Expression;
+    right: Expression;
+};
+export type UnaryExpression = {
+    type: "UnaryExpression";
+    operator: string;
+    argument: Expression;
+};
+export type ConditionalExpression = {
+    type: "ConditionalExpression";
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+};
+export type WhileStatement = {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement[];
+};
+export type BooleanLiteral = {
+    type: "BooleanLiteral";
+    value: boolean;
+};
+export type ArrayLiteral = {
+    type: "ArrayLiteral";
+    elements: Expression[];
+};
+export type ObjectLiteral = {
+    type: "ObjectLiteral";
+    properties: {
+        key: string;
+        value: Expression;
+    }[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/ast/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ast/types.ts"],"names":[],"mappings":"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"}

package/dist/ast/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map