@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-RJIZEJ42.js

@@ -0,0 +1,30 @@
+// src/core/model-ref.ts
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+function formatModelRef(ref, defaultProvider) {
+  const provider = ref.provider ?? defaultProvider;
+  return provider ? `${provider}/${ref.model}` : ref.model;
+}
+function normalizeModelRef(ref, defaultProvider) {
+  return formatModelRef(parseModelRef(ref), defaultProvider);
+}
+
+export {
+  parseModelRef,
+  formatModelRef,
+  normalizeModelRef
+};
+//# sourceMappingURL=chunk-RJIZEJ42.js.map

package/dist/chunk-RPOA7IAE.js

@@ -0,0 +1,150 @@
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/utils/safe-json.ts
+function safeParse(input, maxBytes = 5e6) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
+    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: toErrorMessage(err)
+    };
+  }
+}
+function safeStringify(value, pretty = false) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const replacer = (_k, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message, stack: v.stack };
+    }
+    if (typeof v === "object" && v !== null) {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  };
+  try {
+    return JSON.stringify(value, replacer, pretty ? 2 : void 0) ?? "null";
+  } catch (err) {
+    return JSON.stringify({
+      __serialization_error: toErrorMessage(err)
+    });
+  }
+}
+function sanitizeJsonString(s) {
+  let out = s.trim();
+  out = stripJsonComments(out);
+  out = out.replace(/,(\s*[}\]])/g, "$1");
+  out = escapeControlCharsInStrings(out);
+  try {
+    JSON.parse(out);
+    return out;
+  } catch {
+    return null;
+  }
+}
+function stripCodeFences(s) {
+  const trimmed = s.trim();
+  const opener = /^```[\w+-]*[ \t]*\r?\n?/.exec(trimmed);
+  if (opener) {
+    const inner = trimmed.slice(opener[0].length).replace(/(\r?\n)?[ \t]*```[ \t]*$/, "");
+    return inner.trim();
+  }
+  const embedded = /```[\w+-]*[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```/.exec(trimmed);
+  if (embedded) return (embedded[1] ?? "").trim();
+  return null;
+}
+function escapeControlCharsInStrings(s) {
+  let inString = false;
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charAt(i);
+    if (c === '"' && (i === 0 || s[i - 1] !== "\\")) {
+      inString = !inString;
+      out += c;
+      continue;
+    }
+    const code = c.charCodeAt(0);
+    if (inString && code < 32) {
+      switch (c) {
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          out += `\\u${code.toString(16).padStart(4, "0")}`;
+      }
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function stripJsonComments(s) {
+  let inString = false;
+  let escaped = false;
+  const chars = [];
+  let i = 0;
+  while (i < s.length) {
+    const c = s.charAt(i);
+    if (inString) {
+      chars.push(c);
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === '"') {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      chars.push(c);
+      i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "/") {
+      while (i < s.length && s.charAt(i) !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "*") {
+      const end = s.indexOf("*/", i + 2);
+      if (end === -1) {
+        chars.push(s.slice(i));
+        break;
+      }
+      i = end + 2;
+      continue;
+    }
+    chars.push(c);
+    i++;
+  }
+  return chars.join("");
+}
+
+export {
+  safeParse,
+  safeStringify,
+  sanitizeJsonString,
+  stripCodeFences
+};
+//# sourceMappingURL=chunk-RPOA7IAE.js.map