Developer tools guide: formatting, comparison and JSON patches

Choose one document task: format or minify, recursively sort keys, encode literal text as a JSON string, or decode a JSON string to text. JSON presentation keeps original number tokens, including 9007199254740993, -0 and 1e400.

Steps

1. Choose a task. For JSON presentation choose formatted or compact output and, when formatting, 2 spaces, 4 spaces or tabs.
2. Paste the task input or select one UTF-8 file. A selected file takes priority over the paste.
3. Process the document. Inspect the bounded preview or escaped preview, then copy or download the complete result.

Available options

Task

Format / minify · Sort keys · Escape as string · Unescape string

Output layout

Format · Minify

Indentation

2 spaces · 4 spaces · Tab

Capabilities and limits

• Paste up to 1 MiB or choose one UTF-8 file up to 10 MiB. A selected file replaces the paste. Filenames are limited to 512 UTF-8 bytes.
• Each parsed document may contain at most 200,000 values at value depth 128; the root has depth zero. The complete output is limited to 20 MiB.
• Strict JSON uses unique decoded keys. Comments, trailing commas and non-scalar Unicode strings are refused. At most one leading BOM is ignored for JSON parsing and remains part of source identity.
• String encoding treats input literally, including leading BOM characters; it requires nonempty text. Decoding accepts a JSON string only, and "" produces an empty file. Layout and indentation are inactive in both string tasks.
• Preview shows at most 4,000 Unicode characters. Copy and download include the complete output. Sorting follows UTF-16 key order and keeps arrays ordered; it is a presentation transform.
• Processing stays in this browser and has a 10-second Worker deadline. Cancelling or a failure yields no partial new output.

Test JavaScript regular expressions against local text. Matches include indices and groups; a disposable worker enforces a two-second execution limit and caps the match list at 1,000.

Steps

1. Paste sample text into “Test text”, or load the example.
2. Enter a JavaScript regular expression and choose its flags in Settings, then select “Test expression”.
3. Inspect highlighted matches, positions and capture groups. A count of zero means the pattern found no match.

Available options

Regular expression

Enter as needed

Flags (i, m, g, s, u, y)

g

Capabilities and limits

• A pattern up to 4 KiB, sample text up to 256 KiB, a hard two-second worker limit and at most 1,000 matches. Only JavaScript flags i, m, g, s, u and y are accepted.

Compare two texts line by line with bounded longest-common-subsequence matching. Whitespace comparison is optional; downloadable originals never include visual diff markers.

Steps

1. Paste the original into “Original text” or select a local text file, then paste the changed version into “Revised text”.
2. Choose whether to ignore whitespace differences in Settings, then select “Compare texts”.
3. Read the aligned line numbers and changes. Download either original text from the result area if needed.

Available options

Ignore whitespace differences

Off by default

Capabilities and limits

• Up to 1 MiB per text and 4,000 lines each, with at most four million comparison cells. Large comparisons fail explicitly instead of exhausting the browser.

Parse and format HTML locally with Prettier, including embedded JavaScript and CSS. The result is code text, not executed markup; syntax errors are surfaced rather than converted into a fake successful result.

Steps

1. Paste content into “HTML input” or choose a local file.
2. Review Indentation and JavaScript string quotes before selecting “Format HTML”.
3. Review the HTML text result, then use the available copy or download controls.

Available options

Indentation

2 spaces · 4 spaces

JavaScript string quotes

Double quotes · Single quotes

Capabilities and limits

• Pasted text is limited to 1 MiB; review the result before using it.

Format CSS with a real parser and configurable indentation. The stylesheet is never applied to the main application, and URLs in the CSS are not fetched.

Steps

1. Paste content into “CSS” or choose a local file.
2. Choose the indentation before selecting “Format CSS”.
3. Review the CSS text result, then use the available copy or download controls.

Available options

Indentation

2 spaces · 4 spaces

Capabilities and limits

• Pasted text is limited to 1 MiB; review the result before using it.

Format JavaScript source with a parser, without running it. Choose indentation and quote style; this tool is not a JavaScript interpreter or arbitrary code runner.

Steps

1. Paste content into “JS” or choose a local file.
2. Review Indentation, JavaScript quote style before selecting “Format JavaScript”.
3. Review the JS text result, then use the available copy or download controls.

Available options

Indentation

2 spaces · 4 spaces

JavaScript quote style

Double quotes · Single quotes

Capabilities and limits

• Pasted text is limited to 1 MiB; review the result before using it.

Format PostgreSQL-oriented SQL tokens while preserving quoted strings, identifiers, dollar-quoted bodies and comments. Formatting does not validate database semantics or execute a query.

Steps

1. Paste content into “SQL input” or choose a local file.
2. Confirm that your SQL uses PostgreSQL syntax before selecting “Format SQL”.
3. Review the SQL text result, then use the available copy or download controls.

Available options

Uppercase SQL keywords

On by default

Capabilities and limits

• Pasted text is limited to 1 MiB. Only PostgreSQL-oriented syntax is supported; formatting does not validate the full SQL grammar. Review the result before using it.

Generate UUID version 4 identifiers using Web Crypto randomness with the correct version and variant bits. Availability requires a browser with a secure random source.

Steps

1. Set the number of UUIDs in Settings.
2. Generate and check the count before copying or downloading the UUID v4 list.
3. Review the UUID v4 result, then use the available copy or download controls.

Available options

Number of UUIDs

1

Capabilities and limits

• Input is processed in this browser; unsaved results are lost on refresh.

Generate a TypeScript type alias or a top-level interface from a JSON response, including nested objects, arrays and null values. Fields missing from some objects in a sample array become optional; fields absent from the entire sample cannot be inferred. Large JSON numbers become number, so review precision requirements.

Steps

1. Choose Paste JSON or Choose a file, then provide one JSON object or array.
2. Set the output name and choose a type alias or an interface. Interfaces require a top-level JSON object.
3. Review optional fields, null values and number precision, then copy or download the .ts file.

Available options

Type name

Root

The top-level TypeScript type name, such as ApiResponse. Check for naming conflicts in your project.

Declaration style

Type alias (any JSON value) · Interface (top-level object)

Capabilities and limits

• Types describe this sample only. Optional fields are inferred only when they vary among objects in a sample array. Types do not validate runtime data.
• Processing stays in your browser. Pasted text is limited to 1 MiB.

Convert JSON into XML with a type attribute on every value. Common JSON keys become element names; arrays use item elements. Inspect the mapping before using it with an XML consumer.

Steps

1. Paste JSON or select a UTF-8 JSON file.
2. Check the source validation and whether any keys need the property-name fallback.
3. Create the XML, inspect the type attributes, then copy or download the complete file.

Capabilities and limits

• This is a type-attribute mapping, not an arbitrary XML schema or an exact WCF serializer. Keys that are not simple XML names use <property name="…">.
• JSON strings containing characters prohibited by XML 1.0 cannot be converted. Duplicate JSON keys are rejected.
• Files and input are processed in this browser. No account needed.

Convert XML with mixed text and elements to an order-preserving JSON tree. Inspect name, attrs and children instead of losing text order in a grouped object mapping.

Steps

1. Paste XML or select a UTF-8 .xml or .txt file.
2. Check the root and counts, then convert to the ordered JSON tree.
3. Inspect mixed children and attributes; copy or download the complete JSON.

Capabilities and limits

• XML 1.0 and UTF-8 only. DTD declarations and external entities are rejected. Pasted text is limited to 1 MiB; a file to 10 MiB; the tree to 200,000 elements and 128 levels.
• Children retain source order. Adjacent text and CDATA are combined; comments and processing instructions inside the root are retained, while those outside it are omitted.
• This is a structural tree, not a domain-specific schema. Files are processed in this browser.

Paste compact XML or choose a UTF-8 file. Indent structural elements for inspection while preserving mixed text, CDATA, comments, processing instructions and xml:space regions.

Steps

1. Paste XML or choose one UTF-8 .xml or .txt file.
2. Check the root and protected text regions; then format the XML.
3. Review the whitespace warning and preview, then copy or download the complete result.

Capabilities and limits

• Indentation adds line breaks and replaces whitespace-only text between structural tags. Check whitespace-sensitive consumers before replacing the source.
• Only XML 1.0 and UTF-8 are supported. DTD declarations and external entities are rejected. Paste is limited to 1 MiB, one file to 10 MiB, 200,000 elements and 128 levels.
• Tag spelling, attribute quotes and entity references remain as written. Formatting does not check a business schema or repair invalid XML.

Paste a single column of IDs or names and generate an IN (...) fragment. Choose Text or Number before generating, then check skipped blank rows and repeated values.

Steps

1. Paste one spreadsheet column or open a UTF-8 TXT file with one value per line.
2. Choose Text for IDs/names or Number for numeric columns, and check the preflight counts.
3. Generate the fragment, review its quoting and target column type, then copy or download the complete SQL.

Available options

Value type

text · number

Capabilities and limits

• Processes input locally; no query is executed or sent to a server.
• One value per line, up to 50,000 lines. Blank rows are skipped; duplicates are retained.
• Text uses standard SQL apostrophe doubling. Backslashes and control characters are rejected because SQL dialects differ. Use query parameters for untrusted or dynamic data.
• Large IN lists and NULL matching depend on your database; this tool does not validate a complete query.

Turn CSV rows into an INSERT script for an existing table. Choose the database syntax, separator and empty-cell policy before checking a data sample and saving the script.

Steps

1. Paste CSV with a header row or choose one UTF-8 CSV, TSV or TXT file.
2. Choose PostgreSQL or MySQL, the CSV separator, target table and whether blank cells mean empty strings or SQL NULL.
3. Check row, column and blank-cell counts and the CSV sample; then generate, review, copy or download the complete SQL script.

Available options

Table name

records

SQL dialect

postgres · mysql

CSV separator

Comma · Semicolon · Tab · Pipe

Blank cells

Empty string · SQL NULL

Capabilities and limits

• CSV headers must match columns in an existing table. Headers are trimmed; one or two table-name parts are quoted. No table is created or database connection made.
• All nonblank cells become text literals. Blank cells become empty strings or SQL NULL by choice; literal "NULL" stays text. Check target column types and constraints before executing.
• PostgreSQL backslashes and line breaks use E-string escapes. MySQL values containing backslashes or line breaks use UTF-8 hexadecimal literals to avoid SQL-mode-dependent interpretation; target connection must accept UTF-8.
• Up to 200,000 CSV cells and 1,000 columns; paste is limited to 1 MiB, one UTF-8 file to 10 MiB and SQL output to 20 MiB. Each INSERT has at most 500 rows.

Paste an HTTP(S) cURL request to generate browser fetch code. Check the method, headers and body before copying; the converter never runs the request.

Steps

1. Paste one cURL command copied from API documentation or a terminal.
2. Review the parsed method, host, headers and body size. Fix any unsupported option shown below the input.
3. Generate, inspect and copy the JavaScript. Check secrets and browser CORS behavior before using it.

Capabilities and limits

• Supports one HTTP(S) URL, -X/--request, -H/--header, repeated -d/--data or --data-raw, --data-binary, --json, --url, -G/--get, -I/--head, -L/--location, --compressed and -v/--verbose. Verbose diagnostics are omitted. Local file bodies, shell expansion and other options are rejected.
• Browser fetch cannot set Cookie, Host, Content-Length and other forbidden headers. Such requests are rejected. CORS, credentials and redirects can still differ from cURL. Generated code cannot verify or fix server-side API behavior.
• Conversion runs in this browser. No network request is sent and no account is needed.

Paste raw request or response headers to inspect every field line in order. Repeated fields, including Set-Cookie, stay separate in the JSON export.

Steps

1. Copy the raw header source from a network inspector or log, then paste it or choose a UTF-8 text/log file.
2. Check the start line, field counts and repeated-name count. To inspect values within one comma-list field, enter its name; confirm whether any body lines were ignored.
3. Parse and inspect the ordered table; copy or download the complete JSON with separate entries for repeated fields.

Available options

Comma-list field to split (optional)

Enter as needed

Capabilities and limits

• Parses one HTTP header section: an optional request/response start line or HTTP/2-style pseudo-fields, followed by up to 1,000 field lines. A blank line ends the section; body lines are counted but ignored.
• Field names follow HTTP token syntax. Obsolete folded lines, malformed names, control characters and invalid UTF-8 files are rejected. This is a structural inspector, not a full protocol or security validator.
• Optionally split one chosen comma-list field into quoted values. This is not a general field-semantics parser; Set-Cookie is never split.
• Input stays in this browser. No URL is fetched and no account is needed.

Move configuration between Node-style .env assignments and a JSON object or environment name/value list. Values stay strings, and the reverse conversion checks that every value survives a round trip.

Steps

1. Choose ENV → JSON or JSON → ENV above the input. For ENV → JSON, choose an object or environment name/value list.
2. Paste text or open one UTF-8 .env, .json or .txt file for the selected direction.
3. Review the variable count, convert, then copy or download the complete result.

Available options

Task

ENV → JSON · JSON → ENV

JSON output shape

String object · Environment list

Capabilities and limits

• Supports explicit assignments, optional export, comments, and single, double or backtick quotes including multiline values. Double-quoted \n becomes a newline, as in Node .env parsing; no variable expansion.
• JSON → ENV accepts a top-level object of strings or an environment array of unique name/value strings. Valid variable names and exact representability are required.
• This tool only processes input text; it does not run or send commands found in it.
• Files and input are processed in this browser. No account needed.

Paste a five-field Unix cron time expression, choose the scheduler’s IANA time zone, and inspect the next five matching minutes. Day fields follow Cronie crontab syntax; the daylight-saving preview lists local-time matches, not guaranteed daemon executions.

Steps

1. Paste a five-field expression such as 0 9 * * MON-FRI. Enter the scheduler’s IANA time zone; UTC is the default.
2. Optionally enter an ISO instant with Z or a numeric offset as the starting point. Leave it blank to start from now.
3. Select “Check schedule”. Compare the next local and UTC times, especially around daylight-saving changes, before using the expression in your scheduler.

Available options

Scheduler time zone (IANA)

UTC

Use the zone configured for the scheduler, for example America/New_York or Europe/London.

Starting instant (optional)

Enter as needed

ISO 8601 with Z or an offset, for example 2026-09-23T00:00:00Z. Blank means now.

Capabilities and limits

• Five time fields only, without a command. Supports numbers, three-letter month and weekday names, lists, ranges and steps. Seconds, @aliases, L/W/#/?, random ~ and scheduler-specific extensions are not supported.
• Shows up to five matches within 50 years after the chosen instant. Missing daylight-saving minutes are skipped; repeated local minutes appear with both UTC offsets. Daemon execution and time-zone rules may differ.
• Input stays in this browser. This tool never runs a job or sends a command.

Translate octal permissions including setuid, setgid and sticky bits. Compare owner, group and other permissions separately; a readable mode is not a recommendation to broaden access.

Steps

1. Enter a three- or four-digit octal mode such as 755 or 0755.
2. Select “Calculate permissions” and compare owner, group and other permissions separately.
3. Check the special bits before copying or downloading the result.

Capabilities and limits

• Only three- or four-digit octal permissions are interpreted; local file permissions are not changed.
• The rwx string is an ls-style display, not a relative chmod expression such as g+rw.
• The mode is calculated in this browser. It does not inspect or change any file.

Paste or import an original and a comparison JSON document. Review added, removed and changed values by JSON Pointer, then copy or download the complete two-field report.

Steps

1. Paste both complete JSON values or import a UTF-8 file into each named role. Importing one role preserves the other role.
2. Compare. Correct reported errors in the named source and run again; syntax parsing takes place in the Worker.
3. Inspect the bounded table and counts. Copy or download the complete JSON report to retain all changes.

Capabilities and limits

• Each role accepts paste or one UTF-8 file import up to 1 MiB; both exact-size inputs may be used together. Filenames are limited to 512 UTF-8 bytes. Import replaces only that editable role text.
• Each document allows 200,000 values at value depth 128, with the root at zero. The complete report is limited to 20 MiB.
• Object key order is ignored. Arrays compare at matching indexes; insertions and moves may yield several changes. Exact decimal values compare equal: 1, 1.0 and 1e0 are equal, as are -0 and 0.
• Duplicate decoded keys, comments, trailing commas and non-scalar Unicode are refused. One leading BOM may be ignored for parsing; original BOM and CR/LF remain part of effective source identity until edited.
• Preview shows up to 200 rows, 512 Unicode characters per path and 160 per value. Copy and download retain every full path and compact value, including raw numeric tokens.
• A new or removed subtree is one complete change. The report contains only equal and changes; provenance is shown separately. Browser processing has a 10-second Worker deadline and gives no partial new result on failure.

Preview an RFC 7396 Merge Patch on a JSON document, then download the complete result. Import or paste the original and patch separately.

Steps

1. Paste or import the original JSON and the Merge Patch JSON separately.
2. Object members set to null are deleted; arrays and other nonobject values replace the target.
3. Review deleted keys, whole-array replacements and the complete result before downloading. Use JSON Patch for indexed array edits.

Capabilities and limits

• A null patch member deletes an existing object key. Existing arrays are replaced as whole values; an array element cannot be patched by ID. A nonobject patch replaces the entire document.
• Each UTF-8 JSON input is limited to 1 MiB. The page lists up to 20 deletion and array-replacement paths of each kind; the downloaded result contains the full JSON. No HTTP PATCH request is sent.

Paste or import an original JSON document and a JSON Patch operation array. Apply add, remove, replace, move, copy and test in sequence; review the exact result before downloading.

Steps

1. Paste or import the original JSON and the JSON Patch operation array separately.
2. Write RFC 6901 paths; escape slash as ~1 and tilde as ~0. Array indexes shift after insertions and removals.
3. Run the operations in order, inspect any failed step and path, then review and download the complete JSON result.

Capabilities and limits

• Each UTF-8 JSON input is limited to 1 MiB. The patch must be an array of at most 1,000 operations; compact intermediate JSON is limited to 2 MiB. Duplicate keys and invalid UTF-8 are rejected.
• Array indexes refer to the document after the preceding operation. A failed path or test reports its step and path, with no partial output. Removing the whole root is rejected because no JSON document would remain.
• The preview does not overwrite the original file or send an HTTP PATCH request.
• Result JSON preserves the original number tokens.

Keep global assignments separate from named sections. Convert device or application settings locally, then inspect the complete values before downloading.

Steps

1. Choose INI to JSON or JSON to INI, then paste the input or open a UTF-8 file.
2. For JSON input, use global and sections string maps. Resolve repeated names and unsupported multiline values before running.
3. Check the section, key and value preview. Copy the full result or download the JSON/INI file; keep the original configuration.

Available options

Conversion

INI → JSON · JSON → INI

Capabilities and limits

• One UTF-8 file or pasted input, at most 1 MiB and 50,000 physical lines. When a file is selected it takes precedence; remove it to process pasted input. The page previews up to 200 assignments; the download contains the complete result.
• Supports single-line key=value assignments, [section] headings and whole-line # or ; comments. Spaces and tabs around names and values are trimmed. Quotes, backslashes, extra equals signs and inline #/; remain literal text. Repeated sections and duplicate keys within a section are rejected.
• The JSON structure is {"global":{...},"sections":{"section":{...}}}. All values must be strings. Empty sections are kept. Comments and original spacing are omitted; no DEFAULT inheritance, variable expansion or multiline assignments.
• JSON to INI rejects names or values that cannot survive this syntax, including line breaks and leading/trailing spaces in values. Other INI dialects may interpret the exported file differently; check it in the receiving application.

Move localization messages and Java configuration between .properties and JSON. Java escape rules are applied locally; export uses Unicode escapes so the result can be loaded from an ASCII-compatible byte stream.

Steps

1. Choose Properties to JSON or JSON to Properties, then paste content or open a UTF-8 file.
2. Review Unicode escapes, line continuations and key separators. Fix duplicate decoded keys; use a flat string map for JSON input.
3. Inspect the keys and values. Copy or download the full result, and test the configuration in its receiving application.

Available options

Conversion

Properties → JSON · JSON → Properties

Capabilities and limits

• One UTF-8 input or file, at most 1 MiB and 50,000 physical lines. Selected files take precedence over pasted text. For legacy Latin-1 files, first convert the text encoding to UTF-8. The page previews 200 entries; the download is complete.
• Uses Java Properties.load(Reader) rules: =, : or unescaped whitespace separate key and value; odd trailing backslashes continue a line. Unicode escapes use exactly four hex digits after one u. Unknown escapes drop the backslash, as Java does.
• Duplicate decoded keys are rejected instead of retaining the last occurrence. JSON must be a flat object containing only string values. Empty keys and empty values are supported; comments, original spacing and ordering guarantees are not transferred.
• JSON to Properties emits ASCII with Unicode escapes, including surrogate pairs. It does not expand Spring placeholders, run code, load XML properties, or configure an application. Check the exported settings before use.

Prepare a structural sample for debugging or a support request. Choose the values to replace yourself, review the remaining content, then share the redacted document.

Steps

1. Paste JSON or open a local file, then choose all scalar values or exact object keys.
2. Set the mask. For exact keys, enter a JSON string array such as ["token","email"]. Check case and nested keys.
3. Review the replacement count and paths, inspect retained keys/values, then download the redacted JSON and path report.

Available options

Replacement scope

All scalar values · Exact object keys

Mask string

[redacted]

Capabilities and limits

• One UTF-8 JSON file or pasted document up to 1 MiB. A selected file takes precedence. Parsing rejects duplicate keys, malformed JSON, depth above 128 or more than 200,000 nodes. Pointer report budget is 8 MiB; conservative redacted-output budget is 20 MiB. Preview includes up to 200 replacements.
• All-scalars mode replaces strings, numbers, booleans and null with the mask string; object keys and array/object containers remain. Exact-keys mode uses a nonempty JSON array of up to 1,000 case-sensitive key names and replaces each matching key’s entire value, including a container.
• The mask may have up to 200 Unicode code points. Unselected numbers retain their original lexical text without floating-point rounding. Reports contain only replacement counts, JSON Pointer paths and original types, never stored original values. Keys and paths remain visible, so inspect them before sharing.
• This tool does not detect PII, secrets or credentials automatically. Exact-key mode can leave sensitive values under other keys, and all-scalars mode changes value types. Keep the original locally and review the complete downloaded result.

Rebuild a revised text file from its original and a patch. Check context, line coordinates and EOF markers locally before downloading the complete result.

Steps

1. Open the original file or paste LF text, then paste the single-file unified diff into the patch field.
2. Choose literal payload or explicitly restore CRLF. Verify the original version, declared line positions and no-newline markers.
3. Apply the patch, inspect the hunk summary and complete output, then download patched.txt with its report.

Available options

Patch payload line endings

Literal payload (LF unless CR retained) · Restore CRLF payload after pasting

Capabilities and limits

• Original UTF-8 text and patch each up to 1 MiB. One source file takes precedence over pasted source. At most 50,000 source/output lines, 100,000 patch lines and 2 MiB output. Preview includes up to 200 hunks.
• Supports single-file ---/+++ unified headers, optional git diff/index preamble, exact hunk counts, text creation/deletion and “No newline at end of file” markers. Binary, rename, mode-change and multifile patches are rejected. Header names are labels only; no filesystem path is opened.
• No fuzz or offset search. Removed/context text, declared line coordinates and line endings must match exactly. Default literal payload uses the patch’s record endings. CR-only source records and NUL binary content are unsupported. Any failed hunk stops the entire run without a partial artifact.
• Browsers normalize textarea line endings to LF. To keep a CRLF source, open it as a file and explicitly select CRLF payload when pasting a CRLF patch. This option restores CRLF for all payload records; EOF markers still remove the final ending. Leave literal mode for LF or genuinely mixed endings.

Move content metadata without reformatting the article body. Export metadata as JSON, preserve the exact body boundary, and retain a SHA-256 report for checking.

Steps

1. Open the content file or paste text with a supported file-start metadata header.
2. Extract and inspect metadata.json, the detected format and exact body boundary. No header returns empty metadata and the full body.
3. Download body.md and the extraction report together. Compare the SHA-256 if the body must survive a migration unchanged.

Capabilities and limits

• One UTF-8 file or pasted text up to 1 MiB; a selected file takes precedence. JSON metadata must be a file-start object. YAML starts with --- at column zero and closes with --- or ... at column zero. TOML frontmatter is unsupported.
• JSON extraction ends after the first complete root object and consumes one immediately following line ending as separator. YAML extraction consumes the closing marker and its line ending. A leading UTF-8 BOM is skipped for header detection; without a header the full original body, including BOM, stays unchanged.
• The local safe YAML subset supports mappings, arrays, ordinary scalar values, quoted/flow values and basic block scalars. Tags, anchors, aliases, merge keys, multiple documents and non-finite numbers are rejected. Metadata must be an object; comments and metadata formatting are not retained in JSON.
• Body text after the boundary is not parsed, rendered or executed, including MDX. body.md retains its UTF-8 bytes and line endings. The report provides boundary offsets, body byte count and SHA-256; pasted textarea input may already have LF-normalized endings. Open a file when original CRLF bytes matter.

Check why one file receives different editing rules from another. Enter relative paths and inspect each matched section and the declaration that supplied the final value.

Steps

1. Paste or open one .editorconfig file and enter one relative POSIX file path per line.
2. Inspect final properties, matching sections and declaration line numbers. Check which later rule overrides or unsets a value.
3. Download the complete JSON trace. Compare editor-specific defaults separately when reproducing behavior in an actual editor.

Capabilities and limits

• One UTF-8 EditorConfig file or pasted config up to 64 KiB. Selected file takes precedence. Up to 200 sections, 5,000 declarations, 200 distinct paths of 512 code points, 1,024-character patterns, 5,000,000 matching steps and 50,000 matched declaration applications, with a 20 MiB conservative report budget.
• Paths use case-sensitive relative POSIX spelling under the supplied config directory. No absolute path, backslash, empty component, . or .. component. There is no parent-directory search, child config merge or filesystem access. root is reported from the preamble only.
• Supports EditorConfig 0.17.2 glob *, **, ?, literal/negated sequence classes, nested comma brace choices, increasing signed integer ranges and backslash escapes. Character-class hyphens are literal, not ranges. A slash outside classes anchors at the config directory; patterns without a slash may match basenames at any depth. LF/CRLF config endings are supported; CR-only is rejected.
• Keys and known core property values are lowercased; other values retain case. Later matching declarations win and unset removes a property, with an ordered trace. Only declared properties are shown: editor defaults and derived indent_size/tab_width are not synthesized. Preview shows up to 200 properties; JSON retains every path and trace.

Review what a lockfile declares before investigating dependency duplication. Preserve installation paths and versions without assuming that every entry exists on disk.

Steps

1. Paste or open package-lock.json and confirm that its version is 2 or 3.
2. Inspect declared copies and repeated names, then review aliases, links, workspaces and unknown versions separately.
3. Download the JSON snapshot or path-level CSV. Use package-manager and filesystem checks separately before changing dependencies.

Capabilities and limits

• One UTF-8 package-lock JSON file or pasted input up to 1 MiB; a selected file takes precedence. Supports lockfileVersion 2 or 3 with a packages object, up to 10,000 entries and 512-character relative paths. Duplicate JSON keys and invalid descriptors/paths are rejected.
• The root package entry is excluded from copies. Non-link node_modules entries are installation declarations, and repeated descriptor names are grouped across paths. An explicit name differing from the install slot is classified as an alias. Missing versions stay unknown; version strings are not assumed to be SemVer.
• link:true entries are listed separately with their declared targets, and non-node_modules locations are workspace declarations. v2 legacy dependencies are ignored when packages is read, so the compatibility snapshot is not counted twice. The source kind is a label only; URLs and local targets are never opened.
• This is a lockfile snapshot, not a disk scan, installation verification, vulnerability audit or proof that npm can dedupe packages. JSON keeps exact declared versions; CSV uses spreadsheet-safe cells. Preview shows up to 200 installation declarations.