schema-brief 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## 0.2.0
+
+- Add `extractJsonValues` for extracting multiple JSON payloads from one model response.
+- Add `splitJson` for separating surrounding prose from parsed JSON payloads.
+- Add `repairJsonText` for common non-eval JSON repair such as trailing commas, comments, and smart quotes.
+- Add `createContract` as a reusable schema boundary object with prompt, parse, validate, repair, and provider helpers.
+- Add `toOpenAIResponseFormat`, `toOpenAITool`, and `toAnthropicTool`.
+- Update competitive positioning against structured-output frameworks and JSON extraction utilities.
+
+## 0.1.1
+
+- Improve JSON extraction when non-JSON markdown fences appear before the actual JSON payload.
+- Report invalid schema `pattern` values as validation issues instead of throwing.
+- Add validation support for `allOf`, `anyOf`, `oneOf`, tuple `items`, `uniqueItems`, `minProperties`, `maxProperties`, `exclusiveMinimum`, `exclusiveMaximum`, and `multipleOf`.
+- Expand TypeScript declarations and README supported-keyword documentation.
+
+## 0.1.0
+
+- Initial release with prompt generation, JSON extraction, schema validation, and repair prompts.

package/README.md

@@ -2,7 +2,7 @@
 
 Compact JSON Schema into LLM-ready instructions, extract JSON from model output, and validate the response with the same contract.
 
-`schema-brief` is designed for TypeScript AI applications that need structured output without adding a heavy validation or prompt-engineering dependency. It supports the most common JSON Schema subset used for model outputs: objects, arrays, primitives, `required`, `enum`, `const`, string/number bounds, array bounds, and `additionalProperties`.
+`schema-brief` is designed for TypeScript AI applications that need structured output without adding a heavy validation or prompt-engineering dependency. It supports the most common JSON Schema subset used for model outputs and includes provider helper shapes for OpenAI and Anthropic.
 
 ## Why this exists
 
@@ -23,7 +23,7 @@ This package sits at that boundary: one schema becomes prompt instructions, vali
 | LangChain structured output | Agent pipelines and retries inside LangChain | `schema-brief` is framework-neutral and has no provider/runtime dependency. |
 | Vercel AI SDK structured output | Full-stack apps already using AI SDK | `schema-brief` can be used before or after any model call, including local models and custom SDKs. |
 | AJV and JSON Schema validators | Full JSON Schema compliance and high-throughput validation | `schema-brief` optimizes for the common LLM-output subset and also generates prompt/repair text. |
-| JSON extraction utilities | Pulling JSON out of messy model text | `schema-brief` couples extraction with schema prompt generation and validation feedback. |
+| JSON extraction utilities | Pulling JSON out of messy model text | `schema-brief` extracts one or many JSON payloads and couples extraction with schema prompt generation, validation, repair text, and provider formats. |
 | Zod/Valibot-based helpers | TypeScript schema-first apps | `schema-brief` starts from portable JSON Schema, which fits OpenAPI, MCP, and provider-native structured outputs. |
 
 ## Install
@@ -69,6 +69,21 @@ if (!result.ok) {
 }
 ```
 
+You can also create a reusable contract object:
+
+```js
+import { createContract } from "schema-brief";
+
+const contract = createContract(schema);
+
+await model.generate({
+  system: contract.instructions,
+  response_format: contract.toOpenAIResponseFormat()
+});
+
+const parsed = contract.parse(modelText);
+```
+
 ## API
 
 ### `brief(schema, options?)`
@@ -86,6 +101,18 @@ Options:
 
 Extracts and parses the first complete JSON object or array from raw text or markdown fences.
 
+### `extractJsonValues(text)`
+
+Extracts every complete JSON object or array from raw text.
+
+### `splitJson(text)`
+
+Returns `{ text, json }`, separating surrounding prose from parsed JSON payloads.
+
+### `repairJsonText(text)`
+
+Repairs common LLM JSON formatting mistakes before parsing, including trailing commas, JavaScript-style comments, and smart quotes. It does not evaluate code.
+
 ### `validate(schema, value)`
 
 Validates a value against the supported JSON Schema subset.
@@ -102,10 +129,26 @@ Returns:
 
 Combines `extractJson` and `validate`.
 
+### `createContract(schema, options?)`
+
+Returns a reusable object with `instructions`, `parse`, `validate`, `repairPrompt`, `toOpenAIResponseFormat`, `toOpenAITool`, and `toAnthropicTool`.
+
 ### `repairPrompt(schema, issues)`
 
 Creates a concise prompt asking a model to repair invalid JSON.
 
+### `toOpenAIResponseFormat(schema, options?)`
+
+Creates an OpenAI `response_format` object using `type: "json_schema"`.
+
+### `toOpenAITool(schema, options?)`
+
+Creates an OpenAI tool/function definition from the schema.
+
+### `toAnthropicTool(schema, options?)`
+
+Creates an Anthropic tool definition from the schema.
+
 ## Supported Schema Keywords
 
 - `type`
@@ -117,23 +160,31 @@ Creates a concise prompt asking a model to repair invalid JSON.
 - `required`
 - `additionalProperties`
 - `items`
+- `allOf`
+- `anyOf`
+- `oneOf`
 - `minItems`
 - `maxItems`
+- `uniqueItems`
+- `minProperties`
+- `maxProperties`
 - `minLength`
 - `maxLength`
 - `pattern`
 - `format` for prompt output only
 - `minimum`
 - `maximum`
+- `exclusiveMinimum`
+- `exclusiveMaximum`
+- `multipleOf`
 
 ## Product Roadmap
 
 - Zod adapter: `briefFromZod(schema)`
 - Standard Schema adapter
-- OpenAI, Anthropic, and Vercel AI SDK helpers
 - Token-budgeted schema compression
 - Browser bundle size CI
-- JSON repair suggestions with deterministic patches
+- Schema-aware JSON repair suggestions with deterministic patches
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-brief",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Compact JSON Schema prompts and validate structured LLM outputs with zero dependencies.",
   "type": "module",
   "main": "./src/index.js",
@@ -14,6 +14,7 @@
   "files": [
     "src",
     "examples",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],

package/src/index.d.ts

@@ -20,14 +20,23 @@ export interface JsonSchema {
   required?: readonly string[];
   additionalProperties?: boolean | JsonSchema;
   items?: JsonSchema | readonly JsonSchema[];
+  allOf?: readonly JsonSchema[];
+  anyOf?: readonly JsonSchema[];
+  oneOf?: readonly JsonSchema[];
   minItems?: number;
   maxItems?: number;
+  uniqueItems?: boolean;
+  minProperties?: number;
+  maxProperties?: number;
   minLength?: number;
   maxLength?: number;
   pattern?: string;
   format?: string;
   minimum?: number;
   maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
 }
 
 export interface BriefOptions {
@@ -37,6 +46,17 @@ export interface BriefOptions {
   maxDepth?: number;
 }
 
+export interface SplitJsonResult {
+  text: string[];
+  json: unknown[];
+}
+
+export interface ProviderFormatOptions {
+  name?: string;
+  description?: string;
+  strict?: boolean;
+}
+
 export interface ValidationIssue {
   path: string;
   code: string;
@@ -49,8 +69,53 @@ export type ValidationResult<T = unknown> =
 
 export type ParseResult<T = unknown> = ValidationResult<T>;
 
+export interface OpenAIResponseFormat {
+  type: "json_schema";
+  json_schema: {
+    name: string;
+    strict: boolean;
+    schema: JsonSchema;
+    description?: string;
+  };
+}
+
+export interface OpenAITool {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+    strict: boolean;
+  };
+}
+
+export interface AnthropicTool {
+  name: string;
+  description: string;
+  input_schema: JsonSchema;
+}
+
+export interface OutputContract<T = unknown> {
+  schema: JsonSchema;
+  prompt: string;
+  instructions: string;
+  parse(text: string): ParseResult<T>;
+  validate(value: unknown): ValidationResult<T>;
+  repairPrompt(issues: readonly ValidationIssue[]): string;
+  toOpenAIResponseFormat(options?: ProviderFormatOptions): OpenAIResponseFormat;
+  toOpenAITool(options?: ProviderFormatOptions): OpenAITool;
+  toAnthropicTool(options?: ProviderFormatOptions): AnthropicTool;
+}
+
 export function brief(schema: JsonSchema, options?: BriefOptions): string;
 export function extractJson(text: string): unknown;
+export function extractJsonValues(text: string): unknown[];
+export function splitJson(text: string): SplitJsonResult;
+export function repairJsonText(text: string): string;
 export function validate<T = unknown>(schema: JsonSchema, value: unknown): ValidationResult<T>;
 export function parseStructured<T = unknown>(text: string, schema: JsonSchema): ParseResult<T>;
+export function createContract<T = unknown>(schema: JsonSchema, options?: BriefOptions): OutputContract<T>;
 export function repairPrompt(schema: JsonSchema, issues: readonly ValidationIssue[]): string;
+export function toOpenAIResponseFormat(schema: JsonSchema, options?: ProviderFormatOptions): OpenAIResponseFormat;
+export function toOpenAITool(schema: JsonSchema, options?: ProviderFormatOptions): OpenAITool;
+export function toAnthropicTool(schema: JsonSchema, options?: ProviderFormatOptions): AnthropicTool;

package/src/index.js

@@ -47,18 +47,97 @@ export function extractJson(text) {
     throw new TypeError("extractJson expected a string");
   }
 
-  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const source = fenced ? fenced[1].trim() : text.trim();
+  const values = extractJsonValues(text);
+  if (values.length > 0) {
+    return values[0];
+  }
 
-  try {
-    return JSON.parse(source);
-  } catch {
-    const slice = firstJsonSlice(source);
-    if (!slice) {
-      throw new SyntaxError("No JSON object or array found in text");
+  throw new SyntaxError("No JSON object or array found in text");
+}
+
+/**
+ * Extract every complete JSON object or array from text.
+ *
+ * @param {string} text
+ * @returns {unknown[]}
+ */
+export function extractJsonValues(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("extractJsonValues expected a string");
+  }
+
+  const matches = [];
+  const fences = [...text.matchAll(/```[a-zA-Z0-9_-]*\s*([\s\S]*?)```/g)];
+
+  for (const match of fences) {
+    const values = parseJsonValues(match[1].trim());
+    if (values.length > 0) {
+      matches.push({ start: match.index, values });
     }
-    return JSON.parse(slice);
   }
+
+  const outside = maskRanges(text, fences.map((match) => [match.index, match.index + match[0].length]));
+  for (const match of jsonMatches(outside)) {
+    matches.push({ start: match.start, values: [match.value] });
+  }
+
+  return matches
+    .sort((a, b) => a.start - b.start)
+    .flatMap((match) => match.values);
+}
+
+/**
+ * Separate parsed JSON payloads from surrounding text.
+ *
+ * @param {string} text
+ * @returns {import("./index.d.ts").SplitJsonResult}
+ */
+export function splitJson(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("splitJson expected a string");
+  }
+
+  const parts = [];
+  const json = [];
+  const matches = jsonMatches(text);
+  let cursor = 0;
+
+  for (const match of matches) {
+    const before = text.slice(cursor, match.start).trim();
+    if (before) {
+      parts.push(before);
+    }
+    json.push(match.value);
+    cursor = match.end;
+  }
+
+  const after = text.slice(cursor).trim();
+  if (after) {
+    parts.push(after);
+  }
+
+  return { text: parts, json };
+}
+
+/**
+ * Repair common LLM JSON formatting mistakes without evaluating code.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function repairJsonText(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("repairJsonText expected a string");
+  }
+
+  const normalized = text
+    .replace(/^\uFEFF/, "")
+    .replace(/[\u201C\u201D]/g, "\"")
+    .replace(/[\u2018\u2019]/g, "'");
+
+  return stripJsonComments(normalized)
+    .trim()
+    .replace(/,\s*([}\]])/g, "$1");
 }
 
 /**
@@ -100,6 +179,28 @@ export function parseStructured(text, schema) {
   }
 }
 
+/**
+ * Create a reusable structured-output contract around one schema.
+ *
+ * @param {import("./index.d.ts").JsonSchema} schema
+ * @param {import("./index.d.ts").BriefOptions} [options]
+ * @returns {import("./index.d.ts").OutputContract}
+ */
+export function createContract(schema, options = {}) {
+  const prompt = brief(schema, options);
+  return {
+    schema,
+    prompt,
+    instructions: prompt,
+    parse: (text) => parseStructured(text, schema),
+    validate: (value) => validate(schema, value),
+    repairPrompt: (issues) => repairPrompt(schema, issues),
+    toOpenAIResponseFormat: (providerOptions = {}) => toOpenAIResponseFormat(schema, providerOptions),
+    toOpenAITool: (providerOptions = {}) => toOpenAITool(schema, providerOptions),
+    toAnthropicTool: (providerOptions = {}) => toAnthropicTool(schema, providerOptions)
+  };
+}
+
 /**
  * Create a concise repair prompt from validation issues.
  *
@@ -118,6 +219,64 @@ export function repairPrompt(schema, issues) {
   ].join("\n");
 }
 
+/**
+ * Convert a JSON Schema into OpenAI's json_schema response_format shape.
+ *
+ * @param {import("./index.d.ts").JsonSchema} schema
+ * @param {import("./index.d.ts").ProviderFormatOptions} [options]
+ * @returns {import("./index.d.ts").OpenAIResponseFormat}
+ */
+export function toOpenAIResponseFormat(schema, options = {}) {
+  const jsonSchema = {
+    name: schemaName(schema, options.name),
+    strict: options.strict !== false,
+    schema
+  };
+
+  if (typeof options.description === "string" && options.description.trim()) {
+    jsonSchema.description = options.description.trim();
+  }
+
+  return {
+    type: "json_schema",
+    json_schema: jsonSchema
+  };
+}
+
+/**
+ * Convert a JSON Schema into an OpenAI tool/function definition.
+ *
+ * @param {import("./index.d.ts").JsonSchema} schema
+ * @param {import("./index.d.ts").ProviderFormatOptions} [options]
+ * @returns {import("./index.d.ts").OpenAITool}
+ */
+export function toOpenAITool(schema, options = {}) {
+  return {
+    type: "function",
+    function: {
+      name: schemaName(schema, options.name),
+      description: providerDescription(schema, options),
+      parameters: schema,
+      strict: options.strict !== false
+    }
+  };
+}
+
+/**
+ * Convert a JSON Schema into an Anthropic tool definition.
+ *
+ * @param {import("./index.d.ts").JsonSchema} schema
+ * @param {import("./index.d.ts").ProviderFormatOptions} [options]
+ * @returns {import("./index.d.ts").AnthropicTool}
+ */
+export function toAnthropicTool(schema, options = {}) {
+  return {
+    name: schemaName(schema, options.name),
+    description: providerDescription(schema, options),
+    input_schema: schema
+  };
+}
+
 function describeSchema(schema, context) {
   if (context.depth > context.maxDepth) {
     return "...";
@@ -131,6 +290,18 @@ function describeSchema(schema, context) {
     return schema.enum.map((item) => JSON.stringify(item)).join(" | ");
   }
 
+  if (Array.isArray(schema.oneOf)) {
+    return schema.oneOf.map((child) => describeSchema(child, nextContext(context))).join(" | ");
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    return schema.anyOf.map((child) => describeSchema(child, nextContext(context))).join(" | ");
+  }
+
+  if (Array.isArray(schema.allOf)) {
+    return schema.allOf.map((child) => describeSchema(child, nextContext(context))).join(" & ");
+  }
+
   const type = normalizeType(schema);
 
   if (Array.isArray(type)) {
@@ -154,7 +325,9 @@ function describeSchema(schema, context) {
   }
 
   if (type === "array" || schema.items) {
-    const item = schema.items && !Array.isArray(schema.items)
+    const item = Array.isArray(schema.items)
+      ? `[${schema.items.map((child) => describeSchema(child, nextContext(context))).join(", ")}]`
+      : schema.items
       ? describeSchema(schema.items, nextContext(context))
       : "unknown";
     const range = formatRange(schema.minItems, schema.maxItems, "items");
@@ -190,6 +363,10 @@ function collectDescriptions(schema, path = "$", notes = []) {
 
   if (schema.items && !Array.isArray(schema.items)) {
     collectDescriptions(schema.items, `${path}[]`, notes);
+  } else if (Array.isArray(schema.items)) {
+    schema.items.forEach((child, index) => {
+      collectDescriptions(child, `${path}[${index}]`, notes);
+    });
   }
 
   if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
@@ -215,6 +392,10 @@ function visit(schema, value, path, issues, depth) {
     return;
   }
 
+  if (!validateCompositions(schema, value, path, issues, depth)) {
+    return;
+  }
+
   const expected = normalizeType(schema);
   if (expected && !matchesType(expected, value)) {
     issues.push(issue(path, "type", `Expected ${Array.isArray(expected) ? expected.join(" or ") : expected}`));
@@ -243,6 +424,15 @@ function visit(schema, value, path, issues, depth) {
 function validateObject(schema, value, path, issues, depth) {
   const props = schema.properties ?? {};
   const required = Array.isArray(schema.required) ? schema.required : [];
+  const keys = Object.keys(value);
+
+  if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
+    issues.push(issue(path, "min_properties", `Expected at least ${schema.minProperties} properties`));
+  }
+
+  if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
+    issues.push(issue(path, "max_properties", `Expected at most ${schema.maxProperties} properties`));
+  }
 
   for (const key of required) {
     if (!Object.prototype.hasOwnProperty.call(value, key)) {
@@ -273,7 +463,25 @@ function validateArray(schema, value, path, issues, depth) {
     issues.push(issue(path, "max_items", `Expected at most ${schema.maxItems} items`));
   }
 
-  if (schema.items && !Array.isArray(schema.items)) {
+  if (schema.uniqueItems === true) {
+    const seen = new Set();
+    for (const itemValue of value) {
+      const key = stableStringify(itemValue);
+      if (seen.has(key)) {
+        issues.push(issue(path, "unique_items", "Expected array items to be unique"));
+        break;
+      }
+      seen.add(key);
+    }
+  }
+
+  if (Array.isArray(schema.items)) {
+    schema.items.forEach((itemSchema, index) => {
+      if (index < value.length) {
+        visit(itemSchema, value[index], `${path}[${index}]`, issues, depth + 1);
+      }
+    });
+  } else if (schema.items) {
     value.forEach((itemValue, index) => {
       visit(schema.items, itemValue, `${path}[${index}]`, issues, depth + 1);
     });
@@ -290,7 +498,8 @@ function validateString(schema, value, path, issues) {
   }
 
   if (typeof schema.pattern === "string") {
-    const pattern = new RegExp(schema.pattern);
+    const pattern = safeRegExp(schema.pattern, path, issues);
+    if (!pattern) return;
     if (!pattern.test(value)) {
       issues.push(issue(path, "pattern", `Expected string to match /${schema.pattern}/`));
     }
@@ -313,6 +522,47 @@ function validateNumber(schema, value, path, issues) {
   if (typeof schema.maximum === "number" && value > schema.maximum) {
     issues.push(issue(path, "maximum", `Expected value <= ${schema.maximum}`));
   }
+
+  if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
+    issues.push(issue(path, "exclusive_minimum", `Expected value > ${schema.exclusiveMinimum}`));
+  }
+
+  if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+    issues.push(issue(path, "exclusive_maximum", `Expected value < ${schema.exclusiveMaximum}`));
+  }
+
+  if (typeof schema.multipleOf === "number" && schema.multipleOf > 0) {
+    const quotient = value / schema.multipleOf;
+    if (Math.abs(quotient - Math.round(quotient)) > Number.EPSILON * 100) {
+      issues.push(issue(path, "multiple_of", `Expected a multiple of ${schema.multipleOf}`));
+    }
+  }
+}
+
+function validateCompositions(schema, value, path, issues, depth) {
+  if (Array.isArray(schema.allOf)) {
+    for (const child of schema.allOf) {
+      visit(child, value, path, issues, depth + 1);
+    }
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    const matches = schema.anyOf.filter((child) => validate(child, value).ok);
+    if (matches.length === 0) {
+      issues.push(issue(path, "any_of", "Expected value to match at least one schema"));
+      return false;
+    }
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    const matches = schema.oneOf.filter((child) => validate(child, value).ok);
+    if (matches.length !== 1) {
+      issues.push(issue(path, "one_of", `Expected value to match exactly one schema, matched ${matches.length}`));
+      return false;
+    }
+  }
+
+  return true;
 }
 
 function normalizeType(schema) {
@@ -374,8 +624,155 @@ function stableStringify(value) {
   return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child)}`).join(",")}}`;
 }
 
-function firstJsonSlice(source) {
+function parseJsonValues(source) {
+  try {
+    return [parseJsonText(source)];
+  } catch {
+    return jsonSlices(source)
+      .map((slice) => {
+        try {
+          return parseJsonText(slice.value);
+        } catch {
+          return undefined;
+        }
+      })
+      .filter((value) => value !== undefined);
+  }
+}
+
+function maskRanges(source, ranges) {
+  if (ranges.length === 0) {
+    return source;
+  }
+
+  const chars = [...source];
+  for (const [start, end] of ranges) {
+    for (let index = start; index < end; index += 1) {
+      chars[index] = " ";
+    }
+  }
+  return chars.join("");
+}
+
+function parseJsonText(source) {
+  try {
+    return JSON.parse(source);
+  } catch {
+    return JSON.parse(repairJsonText(source));
+  }
+}
+
+function jsonMatches(source) {
+  return jsonSlices(source)
+    .map((slice) => {
+      try {
+        return {
+          start: slice.start,
+          end: slice.end,
+          value: parseJsonText(slice.value)
+        };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function jsonSlices(source) {
+  const slices = [];
   for (let index = 0; index < source.length; index += 1) {
+    const slice = firstJsonSlice(source, index);
+    if (slice) {
+      slices.push(slice);
+      index = slice.end - 1;
+    }
+  }
+  return slices;
+}
+
+function safeRegExp(pattern, path, issues) {
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : "Invalid regular expression";
+    issues.push(issue(path, "invalid_pattern", detail));
+    return null;
+  }
+}
+
+function schemaName(schema, name) {
+  const candidate = typeof name === "string" && name.trim() ? name : schema.title;
+  const fallback = "structured_output";
+  return (candidate ?? fallback)
+    .toString()
+    .trim()
+    .replace(/[^a-zA-Z0-9_-]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .slice(0, 64) || fallback;
+}
+
+function providerDescription(schema, options) {
+  if (typeof options.description === "string" && options.description.trim()) {
+    return options.description.trim();
+  }
+  if (typeof schema.description === "string" && schema.description.trim()) {
+    return schema.description.trim();
+  }
+  return `Return ${schemaName(schema, options.name)} as JSON.`;
+}
+
+function stripJsonComments(text) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+
+    if (escaped) {
+      output += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      output += char;
+      escaped = inString;
+      continue;
+    }
+
+    if (char === "\"") {
+      output += char;
+      inString = !inString;
+      continue;
+    }
+
+    if (!inString && char === "/" && next === "/") {
+      while (index < text.length && text[index] !== "\n") {
+        index += 1;
+      }
+      output += "\n";
+      continue;
+    }
+
+    if (!inString && char === "/" && next === "*") {
+      index += 2;
+      while (index < text.length && !(text[index] === "*" && text[index + 1] === "/")) {
+        index += 1;
+      }
+      index += 1;
+      continue;
+    }
+
+    output += char;
+  }
+
+  return output;
+}
+
+function firstJsonSlice(source, fromIndex = 0) {
+  for (let index = fromIndex; index < source.length; index += 1) {
     const char = source[index];
     if (char !== "{" && char !== "[") continue;
 
@@ -409,11 +806,15 @@ function firstJsonSlice(source) {
       } else if (current === "}" || current === "]") {
         if (current !== stack.pop()) break;
         if (stack.length === 0) {
-          return source.slice(index, cursor + 1);
+          return {
+            start: index,
+            end: cursor + 1,
+            value: source.slice(index, cursor + 1)
+          };
         }
       }
     }
   }
 
-  return "";
+  return null;
 }