Developer Conversion Workbench | Query, CSS, Escape, Base, and Commit Tools

ConverterRuns in Your Browser (No Uploads)

Use one local developer workbench for exact integer base conversion, ordered query-string inspection, px/rem calculations, strict JSON or JavaScript string escaping, and Conventional Commit message building.

What to do next

Continue with a related workflow or open the next tool that usually follows this task.

How to Use This Tool

Choose the task tab that matches the data you need to inspect or transform.

Set the explicit source rules first: bases, query source, CSS direction and root, escape grammar, or commit fields.

Paste only the bounded value needed for the task and remove credentials, tokens, personal data, or proprietary text before sharing a screen or report.

Run the operation and review warning notes, raw-versus-decoded values, invalid rows, and length metrics instead of relying on the final line alone.

Copy the exact result or download the complete text report; changing any input or setting clears the evaluated result so stale output is not mistaken for current output.

Verify receiving-system behavior separately, including server query rules, CSS context, parser grammar, commit hooks, release policy, and the safety of any URL.

When to Use This Tool

Large identifier and protocol value conversion

Translate exact integer identifiers, masks, or counters across binary, octal, decimal, hexadecimal, and bases up to 36 without safe-integer truncation.

OAuth, analytics, and API query debugging

Compare raw and decoded query entries while retaining duplicate keys, blank syntax, plus signs, malformed escapes, and fragments as evidence.

CSS design-token migration

Calculate small batches of px and rem values against the root size used by a product before editing token files or stylesheet declarations.

JSON fixture and JavaScript literal preparation

Escape or decode string content under the grammar that will consume it, with invalid sequences rejected instead of silently altered.

Conventional Commit drafting

Assemble a reviewable type, optional scope, one-line summary, body, and breaking footer before running repository-specific hooks.

Common Mistakes

Converting large integers with floating-point arithmetic

JavaScript Number values lose integer precision above 9,007,199,254,740,991. The base mode parses digits with BigInt, but its result is still an integer representation rather than a floating-point or signed-width encoding.

Collapsing repeated or blank query entries

Servers disagree about first, last, and list behavior for duplicate keys. Keep source order, missing equals signs, empty segments, and raw values visible until the receiving framework's behavior is verified.

Mixing px and rem in the wrong direction

A rem value pasted into px-to-rem mode is reported as a wrong-unit row instead of being silently converted. Unitless values are accepted as the selected source unit and are called out in the result notes.

Treating every backslash sequence as interchangeable

JSON string content and JavaScript string content use overlapping but different escape grammars. Choose the profile that matches the parser that will consume the result; unsupported and malformed sequences are rejected.

Expecting a commit formatter to understand the code change

The commit builder applies the type, scope, summary, body, and breaking-change fields you provide. It does not inspect a Git diff, infer intent, validate repository policy, or guarantee that a release tool will accept the message.

Examples

Convert a large decimal integer without precision loss

The decimal value is accumulated and rendered with BigInt rather than parseInt or Number.

Input
9007199254740993123456789 (base 10 to base 16)
Output
0x773594000000042F69715

Inspect repeated query keys and plus behavior

Raw entries stay ordered while decoded values show form-query plus-to-space behavior.

Input
https://example.com/search?tag=one&tag=two&q=C%2B%2B+URL&flag#results
Output
tag=[one, two] in source order; q decodes to C++ URL; flag has no equals sign; fragment is excluded

Convert CSS lengths with an explicit root size

Each source token is listed beside its result so unit mistakes remain visible.

Input
16px, 24, -8px with a 16px root
Output
16px -> 1rem
24 -> 1.5rem
-8px -> -0.5rem

Decode JavaScript string content without eval

The strict parser accepts explicit hex and Unicode escapes and rejects unknown or unpaired sequences.

Input
\x41\u0042\u{1F600}
Output
AB😀

Build a scoped breaking Conventional Commit

The output separates the header, body, and breaking footer with blank lines.

Input
type=feat, scope=api/auth, summary=rotate signing keys, breaking=true
Output
feat(api/auth)!: rotate signing keys

BREAKING CHANGE: Clients must refresh cached JWKS data.

Deterministic transformations, parser boundaries, and local processing

Integer base conversion validates each source digit for bases 2 through 36 and uses BigInt multiplication and addition. Optional 0b, 0o, and 0x prefixes must match the selected source base, underscore separators must sit between digits, and output is never routed through floating-point Number arithmetic.

Query inspection separates an absolute-URL source from query-text source. It preserves ampersand order, repeated keys, empty segments, empty keys and values, and missing equals signs. Percent decoding uses UTF-8 semantics, while raw + is shown separately from its form-decoded space value.

CSS length conversion applies px / rootPixels for px-to-rem and rem × rootPixels for rem-to-px. It accepts bounded numeric tokens, including negative values and scientific notation, but rejects a unit that conflicts with the selected direction instead of guessing intent.

JSON escaping uses JSON string grammar. JavaScript mode uses a dedicated parser for supported escape sequences and never evaluates the input as code. Unicode scalar and surrogate-pair checks prevent malformed output from being presented as a clean conversion.

The commit mode assembles a Conventional Commit header, optional body, and BREAKING CHANGE footer from explicit fields. All modes enforce character, UTF-8 byte, item, and output limits; analytics receive only coarse operation metadata and aggregate counts.

Frequently Asked Questions

Can the base converter handle integers larger than Number.MAX_SAFE_INTEGER?

Yes. It validates digits and accumulates the integer with BigInt for bases 2 through 36, with up to 10,000 source digits and a bounded output. It does not parse fractions, exponents, two's-complement widths, or IEEE-754 bit patterns.

Why does a plus sign become a space in a query value?

Query decoding follows application/x-www-form-urlencoded behavior: a raw + represents a space, while %2B represents a literal plus. The report keeps both raw and decoded columns so the distinction remains visible.

Does the CSS converter rewrite an entire stylesheet?

No. It converts a bounded list of numeric px or rem values separated by whitespace or commas. It does not parse declarations, calc(), variables, media queries, percentages, viewport units, or a browser's computed styles.

Is JavaScript unescaping implemented with eval?

No. A dedicated parser handles the supported simple, hex, BMP Unicode, code-point, surrogate-pair, and line-continuation forms. Unknown escapes, trailing backslashes, legacy octal forms, and invalid Unicode are rejected.

Does the commit builder generate a message from my Git diff?

No. It is a deterministic formatter for fields you enter. It never reads a repository, executes Git, sends source code to a model, or decides whether feat, fix, or another type is semantically correct.

Is any pasted value uploaded or stored?

The five transformations run in the current browser and do not make a network request. Operational analytics contain the selected mode and aggregate counts, not the integer, URL, query values, CSS tokens, escaped text, commit summary, body, or generated output.

How This Tool Was Verified

Maintained and tested by Reviewed

Method: Using Developer Conversion Workbench, we reproduced “Keep repeated tags while separating URL and JSON-string decoding” from the exact sample input. The result comparison covered “Choose URL source or query-text source explicitly” and “Compare every raw and decoded entry in order”; the linked test evidence was then checked for “Replacing plus signs globally” and “Using a string unescaper as a URL decoder”.

Expected result: Repeated tag values stayed ordered, q became “C++ URL,” message became two lines only after its second-format decode, the bare flag survived, and #results remained a fragment.

Open the tested workflow

Related workflow guides

Use these focused guides when you need a practical workflow before opening the tool.

Workflow guide

Debug encoded query parameters without double-decoding them

Use this workflow when a callback, search link, webhook, or API request changes plus signs, repeated keys, JSON string escapes, or a nested return URL after more than one parser touches it.

Workflow guide

Fix broken URL query parameters

Use this workflow when a query string is present but the receiving app reads the wrong value, loses a parameter, or treats encoded text as literal data. The goal is to identify the broken layer before rebuilding the link, not to repeatedly encode the entire URL until it appears to work.

Workflow guide

Inspect HTTP response headers before debugging APIs

Use this workflow when a browser request, API response, redirect, or CDN cache behaves differently than expected and you need a bounded, redacted header-level record before editing configuration.

Workflow guide

Create a QR Code for a Link That Scans Reliably

Use this workflow when a website, form, menu, event page, or support link must move from paper, packaging, a PDF, or a presentation into a phone without relying on a tracking or redirect service.

Workflow guide

Fix JavaScript regex escaping across raw patterns and strings

Regex escaping is layered. First identify the source representation, decode only that representation, write the intended raw pattern body, and test it against exact positive and negative text. Then encode the verified body once for the destination JavaScript, JSON, or configuration format instead of adding backslashes by trial and error.

Workflow guide

Encode one URL query value without breaking the outer link

Use this workflow when data inside one query parameter contains spaces, ampersands, equals signs, Unicode, a plus sign, or another complete URL.

Workflow guide

Diagnose and recover one double-encoded query value

Use this workflow when a callback, webhook, proxy, SDK, or copied link contains `%252F`, `%2520`, `%253A`, or another sign that a percent sign was encoded again.

Workflow guide

Debug a callback URL without losing query order or encoding evidence

Use this workflow when an OAuth, SSO, webhook, campaign, or application callback looks correct in a browser but the receiving system reads another path or parameter value.

Related Tools

Continue with another maintained workflow

Browse All Tools