Loading the parity record
Fetching the measured run — the pinned upstream oracle, every symbol and every case.
Fetching the measured run — the pinned upstream oracle, every symbol and every case.
Parity / chalk
Every number on this page was produced by running both implementations over the same cases: the real chalk package pinned at 5.3.0 answers first, and its answer is the expectation the Go port is held to. Nothing is a hand-written expectation, so a new upstream release re-scores the port on its own. See chalk for the port's own documentation. Source: github.com/malcolmston/chalk.
Not a generic diagram: every node below names an artefact of this harness — the pinned package it installed, the runner files it started, the case files it streamed, and the counts it wrote out.
| Case group | Cases | Match | Mismatch | Group parity |
|---|---|---|---|---|
| colors-ansi256 | 96 | 72 | 24 | 75.0% |
| chaining | 91 | 72 | 19 | 79.1% |
| colors-hex | 80 | 78 | 2 | 97.5% |
| colors-rgb | 80 | 74 | 6 | 92.5% |
| colors-bg | 54 | 51 | 3 | 94.4% |
| text | 51 | 51 | 0 | 100.0% |
| errors | 50 | 20 | 30 | 40.0% |
| nesting | 42 | 42 | 0 | 100.0% |
| modifiers | 40 | 40 | 0 | 100.0% |
| colors-basic | 32 | 32 | 0 | 100.0% |
| colors-bright | 30 | 30 | 0 | 100.0% |
| multi-args | 16 | 8 | 8 | 50.0% |
| api | 12 | 8 | 4 | 66.7% |
| deviations | 6 | 0 | 0 | 0.0% |
Every exported symbol of the upstream package, and what the port offers for it. The upstream list is derived mechanically, never from a README: cd parity/chalk/node && node enum.mjs. A symbol with no case is untested, never a match.
| Upstream symbol | Go symbol | Status | Cases | Note |
|---|---|---|---|---|
| chalk.ansi256 | (*chalk.Style).Ansi256 | differs | ansi256-0-l0, ansi256-0-l1, ansi256-0-l2 | at level 1 the port degrades the palette index to ANSI-16; chalk emits 38;5;N unchanged at every level >= 1 |
| chalk.bgAnsi256 | (*chalk.Style).BgAnsi256 | differs | bgansi256-0-l0, bgansi256-0-l1, bgansi256-0-l2 | same level-1 degradation difference as ansi256; also out-of-range indices are wrapped mod 256 by the port and emitted raw by chalk |
| chalk.bgBlack | (*chalk.Style).BgBlack | match | bgBlack-l0, bgBlack-l1, bgBlack-l3 | |
| chalk.bgBlackBright | (*chalk.Style).BgBrightBlack | match | bgBlackBright-l0, bgBlackBright-l1, bgBlackBright-l3 | |
| chalk.bgBlue | (*chalk.Style).BgBlue | differs | bgBlue-l0, bgBlue-l1, bgBlue-l3 | repeating a style of the same category (red.green, bold.bold, bgRed.bgBlue) makes the port re-open the outer code before the final close; chalk emits only the nested pair |
| chalk.bgBlueBright | (*chalk.Style).BgBrightBlue | match | bgBlueBright-l0, bgBlueBright-l1, bgBlueBright-l3 | |
| chalk.bgCyan | (*chalk.Style).BgCyan | match | bgCyan-l0, bgCyan-l1, bgCyan-l3 | |
| chalk.bgCyanBright | (*chalk.Style).BgBrightCyan | match | bgCyanBright-l0, bgCyanBright-l1, bgCyanBright-l3 | |
| chalk.bgGray | (*chalk.Style).BgGray | match | bgGray-l0, bgGray-l1, bgGray-l3 | |
| chalk.bgGreen | (*chalk.Style).BgGreen | match | bgGreen-l0, bgGreen-l1, bgGreen-l3 | |
| chalk.bgGreenBright | (*chalk.Style).BgBrightGreen | match | bgGreenBright-l0, bgGreenBright-l1, bgGreenBright-l3 | |
| chalk.bgGrey | — | missing | bgGrey-l0, bgGrey-l1, bgGrey-l3 | the port has BgGray but no BgGrey alias |
| chalk.bgHex | (*chalk.Style).BgHex | differs | bghex-f80-l0, bghex-f80-l1, bghex-f80-l2 | same as hex |
| chalk.bgMagenta | (*chalk.Style).BgMagenta | match | bgMagenta-l0, bgMagenta-l1, bgMagenta-l3 | |
| chalk.bgMagentaBright | (*chalk.Style).BgBrightMagenta | match | bgMagentaBright-l0, bgMagentaBright-l1, bgMagentaBright-l3 | |
| chalk.bgRed | (*chalk.Style).BgRed | differs | bgRed-l0, bgRed-l1, bgRed-l3 | repeating a style of the same category (red.green, bold.bold, bgRed.bgBlue) makes the port re-open the outer code before the final close; chalk emits only the nested pair |
| chalk.bgRedBright | (*chalk.Style).BgBrightRed | match | bgRedBright-l0, bgRedBright-l1, bgRedBright-l3 | |
| chalk.bgRgb | (*chalk.Style).BgRGB | differs | bgrgb-0-0-0-l0, bgrgb-0-0-0-l1, bgrgb-0-0-0-l2 | same as rgb |
| chalk.bgWhite | (*chalk.Style).BgWhite | match | bgWhite-l0, bgWhite-l1, bgWhite-l3 | |
| chalk.bgWhiteBright | (*chalk.Style).BgBrightWhite | match | bgWhiteBright-l0, bgWhiteBright-l1, bgWhiteBright-l3 | |
| chalk.bgYellow | (*chalk.Style).BgYellow | match | bgYellow-l0, bgYellow-l1, bgYellow-l3 | |
| chalk.bgYellowBright | (*chalk.Style).BgBrightYellow | match | bgYellowBright-l0, bgYellowBright-l1, bgYellowBright-l3 | |
| chalk.black | (*chalk.Style).Black | match | fg-black-l0, fg-black-l1, fg-black-l2 | |
| chalk.blackBright | (*chalk.Style).BrightBlack | match | fg-blackBright-l0, fg-blackBright-l1, fg-blackBright-l3 | |
| chalk.blue | (*chalk.Style).Blue | differs | chain-04-l0, chain-04-l1, chain-04-l2 | repeating a style of the same category (red.green, bold.bold, bgRed.bgBlue) makes the port re-open the outer code before the final close; chalk emits only the nested pair |
| chalk.blueBright | (*chalk.Style).BrightBlue | match | fg-blueBright-l0, fg-blueBright-l1, fg-blueBright-l3 | |
| chalk.bold | (*chalk.Style).Bold | differs | chain-00-l0, chain-00-l1, chain-00-l2 | repeating a style of the same category (red.green, bold.bold, bgRed.bgBlue) makes the port re-open the outer code before the final close; chalk emits only the nested pair |
| chalk.cyan | (*chalk.Style).Cyan | match | fg-cyan-l0, fg-cyan-l1, fg-cyan-l2 | |
| chalk.cyanBright | (*chalk.Style).BrightCyan | match | fg-cyanBright-l0, fg-cyanBright-l1, fg-cyanBright-l3 | |
| chalk.dim | (*chalk.Style).Dim | match | chain-09-l0, chain-09-l1, chain-09-l2 | |
| chalk.gray | (*chalk.Style).Gray | match | chain-19-l0, chain-19-l1, chain-19-l2 | |
| chalk.green | (*chalk.Style).Green | differs | chain-03-l0, chain-03-l1, chain-03-l2 | repeating a style of the same category (red.green, bold.bold, bgRed.bgBlue) makes the port re-open the outer code before the final close; chalk emits only the nested pair |
| chalk.greenBright | (*chalk.Style).BrightGreen | match | fg-greenBright-l0, fg-greenBright-l1, fg-greenBright-l3 | |
| chalk.grey | (*chalk.Style).Grey | match | fg-grey-l0, fg-grey-l1, fg-grey-l3 | |
| chalk.hex | (*chalk.Style).Hex | differs | chain-10-l0, chain-10-l1, chain-10-l2 | malformed input is parsed leniently by chalk (#ff880, #ff88000, #ff8800ff, 0xff8800, " #ff8800", #ff-800) but falls back to black in the port; level-1 ANSI-16 rounding also differs. Neither side ever errors. |
| chalk.hidden | (*chalk.Style).Hidden | match | mod-hidden-l0, mod-hidden-l1, mod-hidden-l2 | |
| chalk.inverse | (*chalk.Style).Inverse | match | chain-18-l0, chain-18-l1, chain-18-l2 | |
| chalk.italic | (*chalk.Style).Italic | match | chain-09-l0, chain-09-l1, chain-09-l2 | |
| chalk.magenta | (*chalk.Style).Magenta | match | fg-magenta-l0, fg-magenta-l1, fg-magenta-l2 | |
| chalk.magentaBright | (*chalk.Style).BrightMagenta | match | fg-magentaBright-l0, fg-magentaBright-l1, fg-magentaBright-l3 | |
| chalk.overline | (*chalk.Style).Overline | match | mod-overline-l0, mod-overline-l1, mod-overline-l2 | |
| chalk.red | (*chalk.Style).Red | differs | chain-00-l0, chain-00-l1, chain-00-l2 | repeating a style of the same category (red.green, bold.bold, bgRed.bgBlue) makes the port re-open the outer code before the final close; chalk emits only the nested pair; also chalk.red('a','b') joins operands with a space where Sprint concatenates and renders nil as <nil> |
| chalk.redBright | (*chalk.Style).BrightRed | match | fg-redBright-l0, fg-redBright-l1, fg-redBright-l3 | |
| chalk.reset | (*chalk.Style).Reset | match | chain-07-l0, chain-07-l1, chain-07-l2 | |
| chalk.rgb | (*chalk.Style).RGB | differs | chain-12-l0, chain-12-l1, chain-12-l2 | level-1 ANSI-16 rounding differs (mid greys, saturated colours pick the bright variant); the port clamps channels to 0-255 where chalk emits them raw |
| chalk.strikethrough | (*chalk.Style).Strikethrough | match | chain-09-l0, chain-09-l1, chain-09-l2 | |
| chalk.underline | (*chalk.Style).Underline | match | chain-02-l0, chain-02-l1, chain-02-l2 | |
| chalk.visible | (*chalk.Style).Visible | match | chain-16-l0, chain-16-l1, chain-16-l2 | |
| chalk.white | (*chalk.Style).White | match | fg-white-l0, fg-white-l1, fg-white-l2 | |
| chalk.whiteBright | (*chalk.Style).BrightWhite | match | fg-whiteBright-l0, fg-whiteBright-l1, fg-whiteBright-l3 | |
| chalk.yellow | (*chalk.Style).Yellow | match | fg-yellow-l0, fg-yellow-l1, fg-yellow-l2 | |
| chalk.yellowBright | (*chalk.Style).BrightYellow | match | fg-yellowBright-l0, fg-yellowBright-l1, fg-yellowBright-l3 | |
| Chalk | chalk.New + chalk.SetLevel | differs | every case (level round-trip: level-0 .. level-3, level-invalid-*) | every case constructs one; chalk rejects a level outside 0..3 while SetLevel accepts any int |
| Chalk.prototype.constructor | chalk.New | match | every case | the same class object as the Chalk row above |
| chalk.level | chalk.GetLevel / chalk.SetLevel | differs | enabled-0, enabled-1, enabled-2 | value round-trips for 0..3; the port also accepts out-of-range levels |
| chalk.length | — | untested | — | Function.prototype.length, not part of the API |
| chalk.name | — | untested | — | Function.prototype.name, not part of the API |
| backgroundColorNames (module export) | — | missing | names-backgroundColorNames | no equivalent export (names-backgroundColorNames) |
| backgroundColors (module export) | — | missing | — | as colors |
| chalkStderr (module export) | — | missing | — | no stderr-specific instance in the port |
| colorNames (module export) | — | missing | names-colorNames | no equivalent export (names-colorNames) |
| colors (module export) | — | missing | — | raw open/close SGR pair table; the port keeps its pairs unexported |
| default (module export) | chalk.Red / chalk.Bold / ... (package-level shortcuts) | untested | — | the auto-detecting default instance; every case builds an explicit new Chalk({level}) instead, so this is not compared |
| foregroundColorNames (module export) | — | missing | names-foregroundColorNames | no equivalent export (names-foregroundColorNames) |
| foregroundColors (module export) | — | missing | — | as colors |
| modifierNames (module export) | — | missing | names-modifierNames | no equivalent export (names-modifierNames) |
| modifiers (module export) | — | missing | — | as colors |
| supportsColor (module export) | chalk.SupportsColor, chalk.HasBasic, chalk.Has256, chalk.HasTrueColor | untested | — | result of environment sniffing; cannot be forced on the upstream side, so deliberately not compared |
| supportsColorStderr (module export) | — | missing | — | the port detects from stdout only |
| a styler called as a template tag (tagged-template usage) | — | missing | template-chain, template-interp, template-plain | chalk 5 dropped its template parser (now chalk-template) but a styler is still callable as a tag; the port has no equivalent -- deviation, see API-DEVIATIONS.md |
| — | chalk.Strip | extra | strip-basic, strip-nested, strip-plain | deviation: chalk leaves this to strip-ansi |
| — | chalk.VisibleLength | extra | — | deviation: chalk leaves this to string-width |
| — | chalk.Enabled, chalk.SetEnabled, chalk.ResetDetection | extra | enabled-0 .. enabled-3 | Enabled compared against chalk.level > 0; the other two have no upstream analogue |
| — | chalk.HasBasic, chalk.Has256, chalk.HasTrueColor, chalk.SupportsColor | extra | — | finer-grained than upstream's single supportsColor object |
| — | (*chalk.Style).Level | extra | level-pin-* | per-style level pin; upstream needs a new Chalk instance instead |
| — | (*chalk.Style).HSL, .HSV, .HWB, .BgHSL, .BgHSV, .BgHWB | extra | — | colour models chalk does not offer |
| — | chalk.HSL, chalk.HSV, chalk.HWB | extra | — | package-level forms of the above |
| — | chalk.HexToRGB, chalk.RGBToHex, chalk.RGBToAnsi16, chalk.RGBToAnsi256, chalk.Ansi256ToRGB, chalk.Ansi256ToAnsi16, chalk.HSLToRGB, chalk.RGBToHSL, chalk.HSVToRGB, chalk.RGBToHSV, chalk.HWBToRGB, chalk.RGBToHWB | extra | — | colour-conversion helpers; chalk keeps the equivalents inside its vendored ansi-styles, unreachable through its exports map, so they are not compared |
| — | (*chalk.Style).Sprint, .Sprintf, .Sprintln, .Print, .Printf, .Println | extra | every render case goes through Sprint | upstream applies a style by calling the styler; Sprint is the port's spelling |
| — | chalk.Red, chalk.Bold, ... (68 package-level shortcuts) | extra | — | one-off forms of the Style methods; the parity cases exercise the Style methods, which share the same implementation |
Every case the harness streamed to both runners, with the exact upstream symbol and Go symbol it exercised. A deliberate, documented difference is a deviation and is counted apart from a mismatch.
| Case | Group | Upstream symbol | Go symbol | Status | Note |
|---|---|---|---|---|---|
| level-0 | api | chalk.level | chalk.GetLevel | match | |
| enabled-0 | api | chalk.level > 0 | chalk.Enabled | match | upstream has no boolean; level 0 means no output |
| level-1 | api | chalk.level | chalk.GetLevel | match | |
| enabled-1 | api | chalk.level > 0 | chalk.Enabled | match | upstream has no boolean; level 0 means no output |
| level-2 | api | chalk.level | chalk.GetLevel | match | |
| enabled-2 | api | chalk.level > 0 | chalk.Enabled | match | upstream has no boolean; level 0 means no output |
| level-3 | api | chalk.level | chalk.GetLevel | match | |
| enabled-3 | api | chalk.level > 0 | chalk.Enabled | match | upstream has no boolean; level 0 means no output |
| names-colorNames | api | chalk.colorNames | — | mismatch | the port exports no style-name list |
| names-modifierNames | api | chalk.modifierNames | — | mismatch | the port exports no style-name list |
| names-foregroundColorNames | api | chalk.foregroundColorNames | — | mismatch | the port exports no style-name list |
| names-backgroundColorNames | api | chalk.backgroundColorNames | — | mismatch | the port exports no style-name list |
| chain-00-l0 | chaining | chalk.red.bold | (*chalk.Style).Sprint | match | |
| chain-00-l1 | chaining | chalk.red.bold | (*chalk.Style).Sprint | match | |
| chain-00-l2 | chaining | chalk.red.bold | (*chalk.Style).Sprint | match | |
| chain-00-l3 | chaining | chalk.red.bold | (*chalk.Style).Sprint | match | |
| chain-01-l0 | chaining | chalk.bold.red | (*chalk.Style).Sprint | match | |
| chain-01-l1 | chaining | chalk.bold.red | (*chalk.Style).Sprint | match | |
| chain-01-l2 | chaining | chalk.bold.red | (*chalk.Style).Sprint | match | |
| chain-01-l3 | chaining | chalk.bold.red | (*chalk.Style).Sprint | match | |
| chain-02-l0 | chaining | chalk.red.bgWhite.underline | (*chalk.Style).Sprint | match | |
| chain-02-l1 | chaining | chalk.red.bgWhite.underline | (*chalk.Style).Sprint | match | |
| chain-02-l2 | chaining | chalk.red.bgWhite.underline | (*chalk.Style).Sprint | match | |
| chain-02-l3 | chaining | chalk.red.bgWhite.underline | (*chalk.Style).Sprint | match | |
| chain-03-l0 | chaining | chalk.red.green | (*chalk.Style).Sprint | match | |
| chain-03-l1 | chaining | chalk.red.green | (*chalk.Style).Sprint | mismatch | |
| chain-03-l2 | chaining | chalk.red.green | (*chalk.Style).Sprint | mismatch | |
| chain-03-l3 | chaining | chalk.red.green | (*chalk.Style).Sprint | mismatch | |
| chain-04-l0 | chaining | chalk.red.green.blue | (*chalk.Style).Sprint | match | |
| chain-04-l1 | chaining | chalk.red.green.blue | (*chalk.Style).Sprint | mismatch | |
| chain-04-l2 | chaining | chalk.red.green.blue | (*chalk.Style).Sprint | mismatch | |
| chain-04-l3 | chaining | chalk.red.green.blue | (*chalk.Style).Sprint | mismatch | |
| chain-05-l0 | chaining | chalk.bgRed.bgBlue | (*chalk.Style).Sprint | match | |
| chain-05-l1 | chaining | chalk.bgRed.bgBlue | (*chalk.Style).Sprint | mismatch | |
| chain-05-l2 | chaining | chalk.bgRed.bgBlue | (*chalk.Style).Sprint | mismatch | |
| chain-05-l3 | chaining | chalk.bgRed.bgBlue | (*chalk.Style).Sprint | mismatch | |
| chain-06-l0 | chaining | chalk.bold.bold | (*chalk.Style).Sprint | match | |
| chain-06-l1 | chaining | chalk.bold.bold | (*chalk.Style).Sprint | mismatch | |
| chain-06-l2 | chaining | chalk.bold.bold | (*chalk.Style).Sprint | mismatch | |
| chain-06-l3 | chaining | chalk.bold.bold | (*chalk.Style).Sprint | mismatch | |
| chain-07-l0 | chaining | chalk.reset.red | (*chalk.Style).Sprint | match | |
| chain-07-l1 | chaining | chalk.reset.red | (*chalk.Style).Sprint | match | |
| chain-07-l2 | chaining | chalk.reset.red | (*chalk.Style).Sprint | match | |
| chain-07-l3 | chaining | chalk.reset.red | (*chalk.Style).Sprint | match | |
| chain-08-l0 | chaining | chalk.red.reset | (*chalk.Style).Sprint | match | |
| chain-08-l1 | chaining | chalk.red.reset | (*chalk.Style).Sprint | match | |
| chain-08-l2 | chaining | chalk.red.reset | (*chalk.Style).Sprint | match | |
| chain-08-l3 | chaining | chalk.red.reset | (*chalk.Style).Sprint | match | |
| chain-09-l0 | chaining | chalk.dim.italic.underline.strikethrough | (*chalk.Style).Sprint | match | |
| chain-09-l1 | chaining | chalk.dim.italic.underline.strikethrough | (*chalk.Style).Sprint | match | |
| chain-09-l2 | chaining | chalk.dim.italic.underline.strikethrough | (*chalk.Style).Sprint | match | |
| chain-09-l3 | chaining | chalk.dim.italic.underline.strikethrough | (*chalk.Style).Sprint | match | |
| chain-10-l0 | chaining | chalk.hex.bold | (*chalk.Style).Sprint | match | |
| chain-10-l1 | chaining | chalk.hex.bold | (*chalk.Style).Sprint | match | |
| chain-10-l2 | chaining | chalk.hex.bold | (*chalk.Style).Sprint | match | |
| chain-10-l3 | chaining | chalk.hex.bold | (*chalk.Style).Sprint | match | |
| chain-11-l0 | chaining | chalk.bold.hex | (*chalk.Style).Sprint | match | |
| chain-11-l1 | chaining | chalk.bold.hex | (*chalk.Style).Sprint | match | |
| chain-11-l2 | chaining | chalk.bold.hex | (*chalk.Style).Sprint | match | |
| chain-11-l3 | chaining | chalk.bold.hex | (*chalk.Style).Sprint | match | |
| chain-12-l0 | chaining | chalk.rgb.bgRgb | (*chalk.Style).Sprint | match | |
| chain-12-l1 | chaining | chalk.rgb.bgRgb | (*chalk.Style).Sprint | match | |
| chain-12-l2 | chaining | chalk.rgb.bgRgb | (*chalk.Style).Sprint | match | |
| chain-12-l3 | chaining | chalk.rgb.bgRgb | (*chalk.Style).Sprint | match | |
| chain-13-l0 | chaining | chalk.ansi256.bgAnsi256 | (*chalk.Style).Sprint | match | |
| chain-13-l1 | chaining | chalk.ansi256.bgAnsi256 | (*chalk.Style).Sprint | mismatch | |
| chain-13-l2 | chaining | chalk.ansi256.bgAnsi256 | (*chalk.Style).Sprint | match | |
| chain-13-l3 | chaining | chalk.ansi256.bgAnsi256 | (*chalk.Style).Sprint | match | |
| chain-14-l0 | chaining | chalk.red.hex | (*chalk.Style).Sprint | match | |
| chain-14-l1 | chaining | chalk.red.hex | (*chalk.Style).Sprint | mismatch | |
| chain-14-l2 | chaining | chalk.red.hex | (*chalk.Style).Sprint | mismatch | |
| chain-14-l3 | chaining | chalk.red.hex | (*chalk.Style).Sprint | mismatch | |
| chain-15-l0 | chaining | chalk.hex.red | (*chalk.Style).Sprint | match | |
| chain-15-l1 | chaining | chalk.hex.red | (*chalk.Style).Sprint | mismatch | |
| chain-15-l2 | chaining | chalk.hex.red | (*chalk.Style).Sprint | mismatch | |
| chain-15-l3 | chaining | chalk.hex.red | (*chalk.Style).Sprint | mismatch | |
| chain-16-l0 | chaining | chalk.visible.red | (*chalk.Style).Sprint | match | |
| chain-16-l1 | chaining | chalk.visible.red | (*chalk.Style).Sprint | match | |
| chain-16-l2 | chaining | chalk.visible.red | (*chalk.Style).Sprint | match | |
| chain-16-l3 | chaining | chalk.visible.red | (*chalk.Style).Sprint | match | |
| chain-17-l0 | chaining | chalk.red.visible | (*chalk.Style).Sprint | match | |
| chain-17-l1 | chaining | chalk.red.visible | (*chalk.Style).Sprint | match | |
| chain-17-l2 | chaining | chalk.red.visible | (*chalk.Style).Sprint | match | |
| chain-17-l3 | chaining | chalk.red.visible | (*chalk.Style).Sprint | match | |
| chain-18-l0 | chaining | chalk.inverse.red.bgBlue | (*chalk.Style).Sprint | match | |
| chain-18-l1 | chaining | chalk.inverse.red.bgBlue | (*chalk.Style).Sprint | match | |
| chain-18-l2 | chaining | chalk.inverse.red.bgBlue | (*chalk.Style).Sprint | match | |
| chain-18-l3 | chaining | chalk.inverse.red.bgBlue | (*chalk.Style).Sprint | match | |
| chain-19-l0 | chaining | chalk.gray.bgGray | (*chalk.Style).Sprint | match | |
| chain-19-l1 | chaining | chalk.gray.bgGray | (*chalk.Style).Sprint | match | |
| chain-19-l2 | chaining | chalk.gray.bgGray | (*chalk.Style).Sprint | match | |
| chain-19-l3 | chaining | chalk.gray.bgGray | (*chalk.Style).Sprint | match | |
| chain-identity-l0 | chaining | chalk (called directly) | (*chalk.Style).Sprint | match | no styles applied |
| chain-identity-l1 | chaining | chalk (called directly) | (*chalk.Style).Sprint | match | no styles applied |
| chain-identity-l3 | chaining | chalk (called directly) | (*chalk.Style).Sprint | match | no styles applied |
| level-pin-0-from-l0 | chaining | new Chalk({level}) | (*chalk.Style).Level | match | upstream rebases onto a Chalk of that level |
| level-pin-1-from-l0 | chaining | new Chalk({level}) | (*chalk.Style).Level | match | upstream rebases onto a Chalk of that level |
| level-pin-2-from-l0 | chaining | new Chalk({level}) | (*chalk.Style).Level | match | upstream rebases onto a Chalk of that level |
| level-pin-3-from-l0 | chaining | new Chalk({level}) | (*chalk.Style).Level | match | upstream rebases onto a Chalk of that level |
| level-pin-0-from-l3 | chaining | new Chalk({level}) | (*chalk.Style).Level | match | upstream rebases onto a Chalk of that level |
chalk's repo also ports 2 packages that each have their own upstream — for example a qs port inside the express repo is measured against npm qs, not against express. Each has a separate harness under parity/chalk/nested/, its own pinned oracle, and its own score; none of them changes the chalk score above. Together they add 296 cases and 52 inventoried symbols.
| Nested port | Its own upstream | Go module | Cases | Mismatch | Deviations | Symbols | Parity |
|---|---|---|---|---|---|---|---|
| chalk | figlet@1.11.4 | github.com/malcolmston/chalk/figlet v0.4.0 | 198 | 0 | 7 | 25 | 100.0% |
| chalk | prompts@2.4.2 | github.com/malcolmston/chalk/prompts v0.4.0 | 98 | 0 | 7 | 27 | 100.0% |