as-test 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Change Log
 
+## 2026-05-26 - v1.4.0
+
+### Dependency-free value serialization (json-as removed)
+
+- feat: as-test no longer depends on or auto-includes `json-as`. Value serialization for assertion reports, snapshots, and `log()` is now handled by a small in-tree stringifier (`assembly/src/stringify.ts`), so `npm install --save-dev as-test` is all you need — `json-as` is no longer a peer dependency.
+- feat: `stringify<T>` renders a broad set of built-in types as JSON: booleans, integers, floats, strings (RFC 8259 escaping, including UTF-16 surrogate handling), `null`, `Date` (quoted ISO-8601), `ArrayBuffer` (array of unsigned byte values), typed arrays / `ArrayBufferView` (element array), `Array`, `StaticArray`, `Set` (value array), and `Map` (JSON object; non-string keys are coerced to quoted strings). Classes render via a transform-generated `toJSON()` or a `"<TypeName>"` placeholder.
+- chore: removed the json-as peer-advisor (`transform/lib/peer-advisor.js`) and the json-as transform-passthrough integration test. Classes decorated `@json`/`@serializable` are skipped by the toJSON injector, so users who want json-as serialization can still add their own `toJSON()` and wire up `--transform json-as`.
+
+### Structural deep equality for matchers
+
+- feat: `.toBe()`, `.toEqual()`, and `.toStrictEqual()` now compare by structure rather than by reference. The EqualsTransform (`transform/lib/equals.js`) synthesises an `__as_test_equals(...)` method for every class that appears as an `expect()`/matcher operand, including nested classes reachable through their fields; the runtime entry point (`assembly/src/reflect.ts`'s `reflectEquals`) handles primitives, nullables, arrays, managed dispatch, and cycle detection, with a strict mode that also checks runtime type ids.
+- feat: hand-written `__as_test_equals` methods are left untouched by the transform, and inheritance chains are supported via a super-call ignore-list pattern.
+
+### Surfacing `log()` output
+
+- feat: after a run, as-test now reports how many `log()` lines were captured and writes them to a single aggregated `.as-test/logs/latest.log`, e.g. `19 logs captured → .as-test/logs/latest.log`. The file groups logs by spec and de-duplicates identical output across modes, tagging each block with the modes that produced it: `[LOG] log.spec.ts (node:bindings, node:wasi):`.
+- feat: `ast test --show-logs` (also on `ast run`) prints the captured logs as a clean grouped block at the end of the run instead of pointing at the file. In a normal run logs stay quiet (just the hint line); `--verbose` and non-TTY output still stream them inline as before.
+- fix: the per-spec readable log's `Log:` section was always empty — it read a `value`/`message` field that never existed on log entries (the field is `text`). It now contains the captured logs.
+
+### Suite / test counting
+
+- change: every grouping block — `describe`, `test`, `it`, `only` (and their skip variants) — now counts as a **suite**, and each `expect()` assertion counts as a **test**. Previously `test`/`it`/`only` weren't counted as suites and an empty one was tallied as a single test, so an `it()` that contained assertions reported `Suites: 0`. As a result a top-level `it()`/`test()` failure now also appears in the end-of-run failure summary (with its location), instead of only the inline assertion line.
+- fix: nested grouping blocks now actually nest. A `describe`/`it`/`test` declared inside another block is parented to the block whose callback is running (`current_suite`) rather than to a stale depth-indexed stack, so `describe`-in-`describe` no longer flattens (the inner block's children were previously attached to the outer block, leaving the inner one empty). The unused `suites`/`depth` registration globals were removed.
+
+### Scoped beforeEach / afterEach
+
+- feat: `beforeEach` and `afterEach` take an optional second argument listing the suite kinds they fire around — `beforeEach(() => {}, ["describe", "test"])`. With no argument the behavior is unchanged: hooks run around test cases (`test` / `it` / `only` and skip variants) and not around grouping blocks like `describe`.
+
+### Watch mode + dependency graph
+
+- feat: `ast test --watch` (`-w`) tracks a per-spec dependency graph (`cli/dependency-graph.ts`) built from the files `asc` actually loads during each build, so editing a shared helper re-runs only the specs that depend on it instead of the whole suite. `asc`'s bundled stdlib and the on-disk package are excluded from the graph to keep it small.
+- feat: press `w` in watch mode to toggle auto-run off (manual invocation) and back on. While paused, edits are remembered but not run — invoke runs yourself with `a` (all) or `space` (retry failing); the footer shows how many changes are pending. Resuming re-runs everything if anything changed while paused.
+
+### Breaking
+
+- chore: `json-as` is no longer installed or auto-included by as-test. Projects that relied on as-test pulling in `json-as`, or on json-as-shaped serialization output in reports/snapshots, should install `json-as` themselves and add a `toJSON()` to the relevant classes. Existing snapshots whose serialized form changed will need `--overwrite-snapshots` once.
+
+### Tooling
+
+- ci: integration tests updated for the new serialization/equality paths (`tests/coverage-points.test.mjs`, new `tests/try-as-dedupe.test.mjs` and `tests/dependency-graph.test.mjs`).
+
 ## 2026-05-22 - v1.3.0
 
 ### `features` config array + arbitrary `--enable` passthrough

package/README.md

@@ -39,12 +39,9 @@ That gives you a basic config file, a sample test, and optionally a sample fuzze
 If you already have a project and just want the package:
 
 ```bash
-npm install --save-dev as-test json-as
+npm install --save-dev as-test
 ```
 
-`json-as` is a required peer dependency (used for value serialization in
-assertions, snapshots, and `log()`)
-
 ## Docs
 
 Full documentation lives at:

package/assembly/index.ts

@@ -14,7 +14,7 @@ import {
   sendFileStart,
   sendReport,
 } from "./util/wipc";
-import { JSON } from "json-as/assembly";
+import { escape, stringify } from "./src/stringify";
 import { bold, green, red } from "./util/format";
 import {
   createFuzzer,
@@ -36,7 +36,8 @@ export {
   IntegerOptions,
   StringOptions,
 } from "./src/fuzz";
-export { __as_test_deep_equal } from "./src/expectation";
+export { reflectEquals } from "./src/reflect";
+export { stringify as __as_test_stringify } from "./src/stringify";
 
 let entrySuites: Suite[] = [];
 let entryFuzzers: FuzzerBase[] = [];
@@ -56,10 +57,6 @@ const FILE = isDefined(ENTRY_FILE) ? ENTRY_FILE : "unknown";
   string
 >();
 // @ts-ignore
-@global let suites: Suite[] = [];
-// @ts-ignore
-@global let depth: i32 = -1;
-// @ts-ignore
 @global let current_suite: Suite | null = null;
 // @ts-ignore
 let before_all_callback: (() => void) | null = null;
@@ -68,6 +65,11 @@ let after_all_callback: (() => void) | null = null;
 
 export let before_each_callback: (() => void) | null = null;
 export let after_each_callback: (() => void) | null = null;
+// Suite kinds each hook fires before/after. `null` = the default set (test
+// cases: test / it / only and their skip variants), excluding grouping blocks
+// like `describe`. A caller-supplied list overrides this.
+export let before_each_kinds: string[] | null = null;
+export let after_each_kinds: string[] | null = null;
 let __test_options!: RunOptions;
 
 /**
@@ -240,7 +242,7 @@ export function xexpect<T>(
  */
 export function log<T>(data: T): void {
   if (!__as_test_log_is_enabled()) return;
-  __as_test_log_serialized(JSON.stringify<T>(data));
+  __as_test_log_serialized(stringify<T>(data));
 }
 
 export function __as_test_log_is_enabled(): bool {
@@ -276,21 +278,43 @@ export function afterAll(callback: () => void): void {
 }
 
 /**
- * Registers a callback function to be executed before each test case is run.
+ * Registers a callback to run before each matching block.
+ *
+ * By default it runs before each test case (`test` / `it` / `only`, plus their
+ * skip variants) and NOT before grouping blocks like `describe`. Pass `kinds`
+ * to run before exactly the listed suite kinds instead, e.g.
+ * `beforeEach(() => {}, ["describe", "test"])`.
  *
- * @param {() => void} callback - The function to be executed before each test case.
+ * @param {() => void} callback - The function to run.
+ * @param {string[] | null} kinds - Suite kinds to run before, or `null` for the
+ *   default test-case kinds.
  */
-export function beforeEach(callback: () => void): void {
+export function beforeEach(
+  callback: () => void,
+  kinds: string[] | null = null,
+): void {
   before_each_callback = callback;
+  before_each_kinds = kinds;
 }
 
 /**
- * Registers a callback function to be executed after each test case is run.
+ * Registers a callback to run after each matching block.
  *
- * @param {() => void} callback - The function to be executed after each test case.
+ * By default it runs after each test case (`test` / `it` / `only`, plus their
+ * skip variants) and NOT after grouping blocks like `describe`. Pass `kinds`
+ * to run after exactly the listed suite kinds instead, e.g.
+ * `afterEach(() => {}, ["describe", "test"])`.
+ *
+ * @param {() => void} callback - The function to run.
+ * @param {string[] | null} kinds - Suite kinds to run after, or `null` for the
+ *   default test-case kinds.
  */
-export function afterEach(callback: () => void): void {
+export function afterEach(
+  callback: () => void,
+  kinds: string[] | null = null,
+): void {
   after_each_callback = callback;
+  after_each_kinds = kinds;
 }
 
 /**
@@ -374,10 +398,7 @@ export function run(options: RunOptions = new RunOptions()): void {
   for (let i = 0; i < entrySuites.length; i++) {
     // @ts-ignore
     const suite = unchecked(entrySuites[i]);
-    suites = [suite];
-
-    current_suite = suite;
-    depth = -1;
+    // @ts-ignore: current_suite is a @global; null between top-level suites
     current_suite = null;
 
     if (hasTopLevelOnly && suite.kind != "only") {
@@ -393,8 +414,7 @@ export function run(options: RunOptions = new RunOptions()): void {
       fileVerdict = "skip";
     }
 
-    suites = [];
-    depth = -1;
+    // @ts-ignore: current_suite is a @global
     current_suite = null;
   }
   time.end = performance.now();
@@ -402,7 +422,7 @@ export function run(options: RunOptions = new RunOptions()): void {
   const report = new FileReport();
   report.suites = entrySuites;
   report.coverage = collectCoverage();
-  sendReport(report.serialize());
+  sendReport(report.toJSON());
 }
 
 function containsOnlySuites(values: Suite[]): bool {
@@ -422,11 +442,11 @@ class FuzzConfig {
 class FuzzReport {
   fuzzers: FuzzerResult[] = [];
 
-  serialize(): string {
+  toJSON(): string {
     let out = '{"fuzzers":[';
     for (let i = 0; i < this.fuzzers.length; i++) {
       if (i) out += ",";
-      out += unchecked(this.fuzzers[i]).serialize();
+      out += unchecked(this.fuzzers[i]).toJSON();
     }
     out += "]}";
     return out;
@@ -443,7 +463,7 @@ function runFuzzers(): void {
     const result = fuzzer.run(config.seed, resolveFuzzerRuns(fuzzer, config));
     report.fuzzers.push(result);
   }
-  sendReport(report.serialize());
+  sendReport(report.toJSON());
 }
 
 function requestFuzzConfig(): FuzzConfig {
@@ -482,20 +502,19 @@ function registerSuite(
   kind: string,
 ): void {
   const suite = new Suite(description, callback, kind);
-  if (depth >= 0) {
-    const _suite = suites[depth];
-    if (_suite.depth == depth) {
-      _suite.addSuite(suite);
-      return;
-    }
-    suite.depth = ++depth;
-    suites.push(suite);
+  // Callbacks run lazily during the run phase, and `current_suite` is always
+  // the suite whose callback is currently executing (the same reference
+  // `expect()`/`log()` resolve against). So a describe/test/it registered from
+  // inside another block nests under it — including describe-in-describe.
+  // `current_suite` is null only at collection time, i.e. a top-level suite.
+  const parent = current_suite;
+  if (parent !== null) {
+    parent.addSuite(suite);
     return;
   }
 
   suite.file = FILE;
   entrySuites.push(suite);
-  suites.push(suite);
 }
 
 function resolveExpectationSuite(): Suite {
@@ -519,7 +538,7 @@ class CoverageReport {
   percent: f64 = 100.0;
   points: CoveragePointReport[] = [];
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"total":' +
       this.total.toString() +
@@ -548,26 +567,26 @@ class CoveragePointReport {
   scopeName: string = "";
   depth: i32 = 0;
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"hash":' +
-      JSON.stringify<string>(this.hash) +
+      escape(this.hash) +
       ',"file":' +
-      JSON.stringify<string>(this.file) +
+      escape(this.file) +
       ',"line":' +
       this.line.toString() +
       ',"column":' +
       this.column.toString() +
       ',"type":' +
-      JSON.stringify<string>(this.type) +
+      escape(this.type) +
       ',"executed":' +
       (this.executed ? "true" : "false") +
       ',"parentHash":' +
-      JSON.stringify<string>(this.parentHash) +
+      escape(this.parentHash) +
       ',"scopeKind":' +
-      JSON.stringify<string>(this.scopeKind) +
+      escape(this.scopeKind) +
       ',"scopeName":' +
-      JSON.stringify<string>(this.scopeName) +
+      escape(this.scopeName) +
       ',"depth":' +
       this.depth.toString() +
       "}"
@@ -579,12 +598,12 @@ class FileReport {
   suites: Suite[] = [];
   coverage: CoverageReport = new CoverageReport();
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"suites":' +
       serializeSuites(this.suites) +
       ',"coverage":' +
-      this.coverage.serialize() +
+      this.coverage.toJSON() +
       "}"
     );
   }
@@ -595,7 +614,7 @@ function serializeSuites(values: Suite[]): string {
   let out = "[";
   for (let i = 0; i < values.length; i++) {
     if (i) out += ",";
-    out += unchecked(values[i]).serialize();
+    out += unchecked(values[i]).toJSON();
   }
   out += "]";
   return out;
@@ -606,7 +625,7 @@ function serializeCoveragePoints(values: CoveragePointReport[]): string {
   let out = "[";
   for (let i = 0; i < values.length; i++) {
     if (i) out += ",";
-    out += unchecked(values[i]).serialize();
+    out += unchecked(values[i]).toJSON();
   }
   out += "]";
   return out;
@@ -690,10 +709,10 @@ export class Result {
     out += ` ${this.arg1 + this.arg2} total\n`;
     return out;
   }
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"name":' +
-      JSON.stringify<string>(this.name) +
+      escape(this.name) +
       ',"arg1":' +
       this.arg1.toString() +
       ',"arg2":' +
@@ -710,7 +729,7 @@ export class Time {
     return formatTime(this.end - this.start);
   }
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"start":' +
       this.start.toString() +

package/assembly/src/expectation.ts

@@ -1,15 +1,39 @@
 import { visualize } from "../util/helpers";
 import { Tests } from "./tests";
-import { JSON } from "json-as/assembly";
 import { namedSnapshotKey, nextUnnamedSnapshotKey } from "..";
 import {
   sendAssertionFailure,
   sendWarning,
   snapshotAssert,
 } from "../util/wipc";
-import { OBJECT, TOTAL_OVERHEAD } from "~lib/rt/common";
+import { reflectEquals } from "./reflect";
+import { stringify, escape } from "./stringify";
 
 let warnedToThrowDisabled = false;
+let warnedSafeStringifyMissing = false;
+
+function safeStringify<T>(value: T): string {
+  if (
+    isManaged<T>() &&
+    !warnedSafeStringifyMissing &&
+    changetype<usize>(value) != 0 &&
+    !isString<T>() &&
+    !isArray<T>()
+  ) {
+    // @ts-expect-error: optional user-supplied serializer
+    if (!isDefined(value.toJSON)) {
+      sendWarning(
+        "Class " +
+          nameof<T>() +
+          " has no toJSON(): string method. Report values render as a `<" +
+          nameof<T>() +
+          ">` placeholder. Add toJSON() returning a JSON string to serialize.",
+      );
+      warnedSafeStringifyMissing = true;
+    }
+  }
+  return stringify<T>(value);
+}
 
 export class Expectation<T> extends Tests {
   public verdict: string = "none";
@@ -18,13 +42,11 @@ export class Expectation<T> extends Tests {
 
   private _left: T;
 
-  // @ts-ignore
+  // @ts-expect-error: used internally
   private _right: u64 = 0;
 
-  // @ts-ignore
   private _not: boolean = false;
 
-  // @ts-ignore
   private _skip: boolean = false;
 
   private _message: string = "";
@@ -492,8 +514,8 @@ export class Expectation<T> extends Tests {
       this._resolve(
         passed,
         "toContain",
-        JSON.stringify<T>(this._left),
-        JSON.stringify<valueof<T>>(value),
+        safeStringify<T>(this._left),
+        safeStringify<valueof<T>>(value),
         message,
       );
       return this;
@@ -519,7 +541,7 @@ export class Expectation<T> extends Tests {
       ? namedSnapshotKey(this._snapshotKey, name)
       : nextUnnamedSnapshotKey(this._snapshotKey);
 
-    const actual = JSON.stringify<T>(this._left);
+    const actual = safeStringify<T>(this._left);
     const res = snapshotAssert(key, actual);
     this._resolve(res.ok, "toMatchSnapshot", actual, res.expected, message);
     return this;
@@ -591,108 +613,44 @@ export class Expectation<T> extends Tests {
    * Tests for equality
    */
   toBe(equals: T, message: string = ""): Expectation<T> {
-    const passed = this._left === equals;
-
+    // Deep structural equality for managed values; `===` semantics for
+    // primitives and strings (reflectEquals does the dispatch).
+    // `toEqual` is kept below as a Jest-familiarity alias.
+    const passed = reflectEquals<T>(this._left, equals, [], false);
     this._resolve(
       passed,
       "toBe",
-      JSON.stringify<T>(this._left),
-      JSON.stringify<T>(equals),
+      safeStringify<T>(this._left),
+      safeStringify<T>(equals),
       message,
     );
     return this;
   }
 
   /**
-   * Tests for deep equality
+   * Alias of `toBe` retained for Jest familiarity.
    */
   toEqual(equals: T, message: string = ""): Expectation<T> {
-    const passed = valueEquals<T>(this._left, equals, false);
-    this._resolve(
-      passed,
-      "toEqual",
-      JSON.stringify<T>(this._left),
-      JSON.stringify<T>(equals),
-      message,
-    );
-    return this;
+    return this.toBe(equals, message);
   }
 
   /**
-   * Tests for strict deep equality
+   * Like `toBe` but also requires the runtime type (rtId) of the
+   * operands to match for managed values.
    */
   toStrictEqual(equals: T, message: string = ""): Expectation<T> {
-    const passed = valueEquals<T>(this._left, equals, true);
+    const passed = reflectEquals<T>(this._left, equals, [], true);
     this._resolve(
       passed,
       "toStrictEqual",
-      JSON.stringify<T>(this._left),
-      JSON.stringify<T>(equals),
+      safeStringify<T>(this._left),
+      safeStringify<T>(equals),
       message,
     );
     return this;
   }
 }
 
-function arrayEquals<T>(a: T[], b: T[], strict: bool): boolean {
-  if (a.length != b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (!valueEquals<T>(unchecked(a[i]), unchecked(b[i]), strict)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function valueEquals<T>(left: T, right: T, strict: bool): bool {
-  if (isBoolean<T>() || isString<T>() || isInteger<T>() || isFloat<T>()) {
-    return left === right;
-  }
-
-  if (isNullable<T>()) {
-    const leftPtr = changetype<usize>(left);
-    const rightPtr = changetype<usize>(right);
-    if (leftPtr == 0 || rightPtr == 0) return leftPtr == rightPtr;
-  }
-
-  if (isArray<T>()) {
-    return arrayEquals<valueof<T>>(
-      changetype<valueof<T>[]>(left),
-      changetype<valueof<T>[]>(right),
-      strict,
-    );
-  }
-
-  if (isManaged<T>()) {
-    return managedEquals<T>(left, right, strict);
-  }
-
-  abort(
-    `Unsupported equality matcher for ${nameof<T>()}. Use toBe() for identity or compare fields explicitly.`,
-  );
-  return false;
-}
-
-export function __as_test_deep_equal<T>(left: T, right: T, strict: bool): bool {
-  return valueEquals<T>(left, right, strict);
-}
-
-function managedEquals<T>(left: T, right: T, strict: bool): bool {
-  const leftPtr = changetype<usize>(left);
-  const rightPtr = changetype<usize>(right);
-  if (leftPtr == rightPtr) return true;
-  if (leftPtr == 0 || rightPtr == 0) return false;
-
-  if (strict) {
-    const leftObject = changetype<OBJECT>(leftPtr - TOTAL_OVERHEAD);
-    const rightObject = changetype<OBJECT>(rightPtr - TOTAL_OVERHEAD);
-    if (leftObject.rtId != rightObject.rtId) return false;
-  }
-
-  // @ts-ignore
-  return left.__as_test_equals(right, strict);
-}
-
 function isTruthy<T>(value: T): bool {
   if (isBoolean<T>()) {
     return value as bool;
@@ -714,5 +672,5 @@ function isTruthy<T>(value: T): bool {
 }
 
 function q(value: string): string {
-  return JSON.stringify<string>(value);
+  return escape(value);
 }

package/assembly/src/fuzz.ts

@@ -1,7 +1,7 @@
-import { JSON } from "json-as/assembly";
+import { escape, stringify } from "./stringify";
 
 function quote(s: string): string {
-  return JSON.stringify<string>(s);
+  return escape(s);
 }
 
 export class StringOptions {
@@ -615,7 +615,7 @@ export class FuzzerResult {
   public failureMessage: string = "";
   public failures: FuzzFailure[] = [];
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"name":"' +
       this.name +
@@ -653,7 +653,7 @@ export class FuzzFailure {
   public seed: u64 = 0;
   public input: string = "";
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"run":' +
       this.run.toString() +
@@ -881,7 +881,7 @@ export class Fuzzer1<A, R> extends FuzzerBase {
         );
       } else {
         this.generator(seed, (a: A): R => {
-          __as_test_fuzz_input = "[" + JSON.stringify<A>(a) + "]";
+          __as_test_fuzz_input = "[" + stringify<A>(a) + "]";
           return changetype<(a: A) => R>(__fuzz_run1)(a);
         });
       }
@@ -952,7 +952,7 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
       } else {
         this.generator(seed, (a: A, b: B): R => {
           __as_test_fuzz_input =
-            "[" + JSON.stringify<A>(a) + "," + JSON.stringify<B>(b) + "]";
+            "[" + stringify<A>(a) + "," + stringify<B>(b) + "]";
           return changetype<(a: A, b: B) => R>(__fuzz_run2)(a, b);
         });
       }
@@ -1026,11 +1026,11 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
         )(seed, (a: A, b: B, c: C): R => {
           __as_test_fuzz_input =
             "[" +
-            JSON.stringify<A>(a) +
+            stringify<A>(a) +
             "," +
-            JSON.stringify<B>(b) +
+            stringify<B>(b) +
             "," +
-            JSON.stringify<C>(c) +
+            stringify<C>(c) +
             "]";
           return changetype<(a: A, b: B, c: C) => R>(__fuzz_run3)(a, b, c);
         });
@@ -1208,7 +1208,7 @@ function serializeFuzzFailures(values: FuzzFailure[]): string {
   let out = "[";
   for (let i = 0; i < values.length; i++) {
     if (i) out += ",";
-    out += unchecked(values[i]).serialize();
+    out += unchecked(values[i]).toJSON();
   }
   out += "]";
   return out;

package/assembly/src/log.ts

@@ -1,4 +1,4 @@
-import { JSON } from "json-as/assembly";
+import { escape, stringify } from "./stringify";
 
 import { sendLog } from "../util/wipc";
 
@@ -14,14 +14,14 @@ export class Log {
     sendLog(this.file, this.depth, this.text);
   }
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"order":' +
       this.order.toString() +
       ',"depth":' +
       this.depth.toString() +
       ',"text":' +
-      JSON.stringify<string>(this.text) +
+      escape(this.text) +
       "}"
     );
   }