bonescript-compiler 0.5.3 → 0.5.5

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 BoneScript Contributors
-
-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.
+MIT License
+
+Copyright (c) 2026 BoneScript Contributors
+
+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.

package/dist/algorithm_catalog.js

@@ -27,45 +27,45 @@ exports.CATALOG = {
         ],
         output: { type: "{path: string[], distance: number} | null", description: "shortest path or null if unreachable" },
         complexity: "O((V + E) log V)",
-        emit: (b) => `
-function shortestPath(
-  graph: Map<string, { node: string; weight: number }[]>,
-  source: string,
-  target: string
-): { path: string[]; distance: number } | null {
-  const distances = new Map<string, number>();
-  const previous = new Map<string, string>();
-  const queue: { node: string; distance: number }[] = [];
-
-  for (const node of graph.keys()) distances.set(node, Infinity);
-  distances.set(source, 0);
-  queue.push({ node: source, distance: 0 });
-
-  while (queue.length > 0) {
-    queue.sort((a, b) => a.distance - b.distance);
-    const current = queue.shift()!;
-    if (current.node === target) break;
-    if (current.distance > (distances.get(current.node) ?? Infinity)) continue;
-
-    for (const edge of graph.get(current.node) || []) {
-      const newDist = current.distance + edge.weight;
-      if (newDist < (distances.get(edge.node) ?? Infinity)) {
-        distances.set(edge.node, newDist);
-        previous.set(edge.node, current.node);
-        queue.push({ node: edge.node, distance: newDist });
-      }
-    }
-  }
-
-  if (!previous.has(target) && source !== target) return null;
-  const path: string[] = [];
-  let current: string | undefined = target;
-  while (current !== undefined) {
-    path.unshift(current);
-    current = previous.get(current);
-  }
-  return { path, distance: distances.get(target) || 0 };
-}
+        emit: (b) => `
+function shortestPath(
+  graph: Map<string, { node: string; weight: number }[]>,
+  source: string,
+  target: string
+): { path: string[]; distance: number } | null {
+  const distances = new Map<string, number>();
+  const previous = new Map<string, string>();
+  const queue: { node: string; distance: number }[] = [];
+
+  for (const node of graph.keys()) distances.set(node, Infinity);
+  distances.set(source, 0);
+  queue.push({ node: source, distance: 0 });
+
+  while (queue.length > 0) {
+    queue.sort((a, b) => a.distance - b.distance);
+    const current = queue.shift()!;
+    if (current.node === target) break;
+    if (current.distance > (distances.get(current.node) ?? Infinity)) continue;
+
+    for (const edge of graph.get(current.node) || []) {
+      const newDist = current.distance + edge.weight;
+      if (newDist < (distances.get(edge.node) ?? Infinity)) {
+        distances.set(edge.node, newDist);
+        previous.set(edge.node, current.node);
+        queue.push({ node: edge.node, distance: newDist });
+      }
+    }
+  }
+
+  if (!previous.has(target) && source !== target) return null;
+  const path: string[] = [];
+  let current: string | undefined = target;
+  while (current !== undefined) {
+    path.unshift(current);
+    current = previous.get(current);
+  }
+  return { path, distance: distances.get(target) || 0 };
+}
 `,
     },
     topological_sort: {
@@ -77,29 +77,29 @@ function shortestPath(
         ],
         output: { type: "string[] | null", description: "topological order, or null if cycle exists" },
         complexity: "O(V + E)",
-        emit: (b) => `
-function topologicalSort(graph: Map<string, string[]>): string[] | null {
-  const inDegree = new Map<string, number>();
-  for (const node of graph.keys()) inDegree.set(node, 0);
-  for (const [, neighbors] of graph) {
-    for (const n of neighbors) inDegree.set(n, (inDegree.get(n) || 0) + 1);
-  }
-
-  const queue: string[] = [];
-  for (const [node, deg] of inDegree) if (deg === 0) queue.push(node);
-
-  const result: string[] = [];
-  while (queue.length > 0) {
-    const node = queue.shift()!;
-    result.push(node);
-    for (const neighbor of graph.get(node) || []) {
-      inDegree.set(neighbor, (inDegree.get(neighbor) || 0) - 1);
-      if (inDegree.get(neighbor) === 0) queue.push(neighbor);
-    }
-  }
-
-  return result.length === graph.size ? result : null;
-}
+        emit: (b) => `
+function topologicalSort(graph: Map<string, string[]>): string[] | null {
+  const inDegree = new Map<string, number>();
+  for (const node of graph.keys()) inDegree.set(node, 0);
+  for (const [, neighbors] of graph) {
+    for (const n of neighbors) inDegree.set(n, (inDegree.get(n) || 0) + 1);
+  }
+
+  const queue: string[] = [];
+  for (const [node, deg] of inDegree) if (deg === 0) queue.push(node);
+
+  const result: string[] = [];
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+    result.push(node);
+    for (const neighbor of graph.get(node) || []) {
+      inDegree.set(neighbor, (inDegree.get(neighbor) || 0) - 1);
+      if (inDegree.get(neighbor) === 0) queue.push(neighbor);
+    }
+  }
+
+  return result.length === graph.size ? result : null;
+}
 `,
     },
     // ─── Search ───────────────────────────────────────────────────────────────
@@ -113,17 +113,17 @@ function topologicalSort(graph: Map<string, string[]>): string[] | null {
         ],
         output: { type: "number", description: "index of target or -1 if not found" },
         complexity: "O(log n)",
-        emit: (b) => `
-function binarySearch<T>(items: T[], target: T): number {
-  let low = 0, high = items.length - 1;
-  while (low <= high) {
-    const mid = Math.floor((low + high) / 2);
-    if (items[mid] === target) return mid;
-    if (items[mid] < target) low = mid + 1;
-    else high = mid - 1;
-  }
-  return -1;
-}
+        emit: (b) => `
+function binarySearch<T>(items: T[], target: T): number {
+  let low = 0, high = items.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (items[mid] === target) return mid;
+    if (items[mid] < target) low = mid + 1;
+    else high = mid - 1;
+  }
+  return -1;
+}
 `,
     },
     // ─── Matching ─────────────────────────────────────────────────────────────
@@ -138,37 +138,37 @@ function binarySearch<T>(items: T[], target: T): number {
         ],
         output: { type: "Map<string, string>", description: "matching from left to right" },
         complexity: "O(E sqrt(V))",
-        emit: (b) => `
-function bipartiteMatching(
-  left: string[],
-  right: string[],
-  edges: { from: string; to: string }[]
-): Map<string, string> {
-  const adj = new Map<string, string[]>();
-  for (const e of edges) {
-    if (!adj.has(e.from)) adj.set(e.from, []);
-    adj.get(e.from)!.push(e.to);
-  }
-
-  const matchL = new Map<string, string>();
-  const matchR = new Map<string, string>();
-
-  function dfs(u: string, visited: Set<string>): boolean {
-    for (const v of adj.get(u) || []) {
-      if (visited.has(v)) continue;
-      visited.add(v);
-      if (!matchR.has(v) || dfs(matchR.get(v)!, visited)) {
-        matchL.set(u, v);
-        matchR.set(v, u);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  for (const u of left) dfs(u, new Set());
-  return matchL;
-}
+        emit: (b) => `
+function bipartiteMatching(
+  left: string[],
+  right: string[],
+  edges: { from: string; to: string }[]
+): Map<string, string> {
+  const adj = new Map<string, string[]>();
+  for (const e of edges) {
+    if (!adj.has(e.from)) adj.set(e.from, []);
+    adj.get(e.from)!.push(e.to);
+  }
+
+  const matchL = new Map<string, string>();
+  const matchR = new Map<string, string>();
+
+  function dfs(u: string, visited: Set<string>): boolean {
+    for (const v of adj.get(u) || []) {
+      if (visited.has(v)) continue;
+      visited.add(v);
+      if (!matchR.has(v) || dfs(matchR.get(v)!, visited)) {
+        matchL.set(u, v);
+        matchR.set(v, u);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  for (const u of left) dfs(u, new Set());
+  return matchL;
+}
 `,
     },
     // ─── Scheduling ────────────────────────────────────────────────────────────
@@ -182,16 +182,16 @@ function bipartiteMatching(
         ],
         output: { type: "Map<W, T[]>", description: "assignments per worker" },
         complexity: "O(n)",
-        emit: (b) => `
-function roundRobin<T, W>(items: T[], workers: W[]): Map<W, T[]> {
-  const result = new Map<W, T[]>();
-  for (const w of workers) result.set(w, []);
-  for (let i = 0; i < items.length; i++) {
-    const w = workers[i % workers.length];
-    result.get(w)!.push(items[i]);
-  }
-  return result;
-}
+        emit: (b) => `
+function roundRobin<T, W>(items: T[], workers: W[]): Map<W, T[]> {
+  const result = new Map<W, T[]>();
+  for (const w of workers) result.set(w, []);
+  for (let i = 0; i < items.length; i++) {
+    const w = workers[i % workers.length];
+    result.get(w)!.push(items[i]);
+  }
+  return result;
+}
 `,
     },
     // ─── Stats ─────────────────────────────────────────────────────────────────
@@ -204,16 +204,16 @@ function roundRobin<T, W>(items: T[], workers: W[]): Map<W, T[]> {
         ],
         output: { type: "number", description: "weighted average" },
         complexity: "O(n)",
-        emit: (b) => `
-function weightedAverage(items: { value: number; weight: number }[]): number {
-  let totalWeight = 0;
-  let weightedSum = 0;
-  for (const item of items) {
-    totalWeight += item.weight;
-    weightedSum += item.value * item.weight;
-  }
-  return totalWeight === 0 ? 0 : weightedSum / totalWeight;
-}
+        emit: (b) => `
+function weightedAverage(items: { value: number; weight: number }[]): number {
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const item of items) {
+    totalWeight += item.weight;
+    weightedSum += item.value * item.weight;
+  }
+  return totalWeight === 0 ? 0 : weightedSum / totalWeight;
+}
 `,
     },
     percentile: {
@@ -226,16 +226,16 @@ function weightedAverage(items: { value: number; weight: number }[]): number {
         ],
         output: { type: "number", description: "kth percentile value" },
         complexity: "O(n log n)",
-        emit: (b) => `
-function percentile(values: number[], k: number): number {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const idx = (k / 100) * (sorted.length - 1);
-  const lower = Math.floor(idx);
-  const upper = Math.ceil(idx);
-  if (lower === upper) return sorted[lower];
-  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
-}
+        emit: (b) => `
+function percentile(values: number[], k: number): number {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = (k / 100) * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
+}
 `,
     },
     // ─── Sort ──────────────────────────────────────────────────────────────────
@@ -250,11 +250,11 @@ function percentile(values: number[], k: number): number {
         ],
         output: { type: "T[]", description: "sorted array" },
         complexity: "O(n log n)",
-        emit: (b) => `
-function rankBy<T>(items: T[], scoreFn: (item: T) => number, order: "asc" | "desc"): T[] {
-  const sign = order === "asc" ? 1 : -1;
-  return [...items].sort((a, b) => sign * (scoreFn(a) - scoreFn(b)));
-}
+        emit: (b) => `
+function rankBy<T>(items: T[], scoreFn: (item: T) => number, order: "asc" | "desc"): T[] {
+  const sign = order === "asc" ? 1 : -1;
+  return [...items].sort((a, b) => sign * (scoreFn(a) - scoreFn(b)));
+}
 `,
     },
     // ─── Crypto / Hashing ──────────────────────────────────────────────────────
@@ -269,33 +269,33 @@ function rankBy<T>(items: T[], scoreFn: (item: T) => number, order: "asc" | "des
         ],
         output: { type: "string", description: "node assigned to key" },
         complexity: "O(N log N) build, O(log N) lookup",
-        emit: (b) => `
-function consistentHash(key: string, nodes: string[], replicas: number = 100): string {
-  if (nodes.length === 0) throw new Error("No nodes available");
-
-  function fnv1a(s: string): number {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) {
-      hash ^= s.charCodeAt(i);
-      hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0;
-    }
-    return hash;
-  }
-
-  const ring: { hash: number; node: string }[] = [];
-  for (const node of nodes) {
-    for (let i = 0; i < replicas; i++) {
-      ring.push({ hash: fnv1a(node + ":" + i), node });
-    }
-  }
-  ring.sort((a, b) => a.hash - b.hash);
-
-  const target = fnv1a(key);
-  for (const entry of ring) {
-    if (entry.hash >= target) return entry.node;
-  }
-  return ring[0].node;
-}
+        emit: (b) => `
+function consistentHash(key: string, nodes: string[], replicas: number = 100): string {
+  if (nodes.length === 0) throw new Error("No nodes available");
+
+  function fnv1a(s: string): number {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+      hash ^= s.charCodeAt(i);
+      hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0;
+    }
+    return hash;
+  }
+
+  const ring: { hash: number; node: string }[] = [];
+  for (const node of nodes) {
+    for (let i = 0; i < replicas; i++) {
+      ring.push({ hash: fnv1a(node + ":" + i), node });
+    }
+  }
+  ring.sort((a, b) => a.hash - b.hash);
+
+  const target = fnv1a(key);
+  for (const entry of ring) {
+    if (entry.hash >= target) return entry.node;
+  }
+  return ring[0].node;
+}
 `,
     },
 };

package/dist/cli.d.ts

@@ -1,5 +1,4 @@
 /**
- * BoneScript compiler CLI — dispatcher
- * Each command lives in its own file under commands/.
+ * BoneScript compiler CLI
  */
 export {};