@angular-wave/angular.ts 0.9.4 → 0.9.6

package/src/core/interpolate/interpolate.spec.js

@@ -1,601 +0,0 @@
-import { createInjector } from "../di/injector.js";
-import { Angular } from "../../angular.js";
-import { wait } from "../../shared/test-utils.js";
-
-describe("$interpolate", () => {
-  let $interpolate, $injector, $rootScope, $sce;
-
-  beforeEach(() => {
-    window.angular = new Angular();
-    $injector = createInjector(["ng"]);
-    $interpolate = $injector.get("$interpolate");
-    $rootScope = $injector.get("$rootScope");
-    $sce = $injector.get("$sce");
-  });
-
-  it("produces an identity function for static content", function () {
-    const interp = $interpolate("hello");
-    expect(interp instanceof Function).toBe(true);
-    expect(interp()).toEqual("hello");
-  });
-
-  it("evaluates a single expression", function () {
-    const interp = $interpolate("{{anAttr}}");
-    expect(interp({ anAttr: "42" })).toEqual("42");
-  });
-
-  it("passes through ill-defined interpolations", function () {
-    const interp = $interpolate("why u no }}work{{");
-    expect(interp({})).toEqual("why u no }}work{{");
-  });
-
-  it("evaluates many expressions", function () {
-    const interp = $interpolate("First {{anAttr}}, then {{anotherAttr}}!");
-    expect(interp({ anAttr: "42", anotherAttr: "43" })).toEqual(
-      "First 42, then 43!",
-    );
-  });
-
-  it("turns nulls into empty strings", function () {
-    const interp = $interpolate("{{aNull}}");
-    expect(interp({ aNull: null })).toEqual("");
-  });
-
-  it("turns undefineds into empty strings", function () {
-    const interp = $interpolate("{{anUndefined}}");
-    expect(interp({})).toEqual("");
-  });
-
-  it("turns numbers into strings", function () {
-    const interp = $interpolate("{{aNumber}}");
-    expect(interp({ aNumber: 42 })).toEqual("42");
-  });
-
-  it("turns booleans into strings", function () {
-    const interp = $interpolate("{{aBoolean}}");
-    expect(interp({ aBoolean: true })).toEqual("true");
-  });
-
-  it("turns arrays into JSON strings", function () {
-    const interp = $interpolate("{{anArray}}");
-    expect(interp({ anArray: [1, 2, [3]] })).toEqual("[1,2,[3]]");
-  });
-
-  it("turns objects into JSON strings", function () {
-    const interp = $interpolate("{{anObject}}");
-    expect(interp({ anObject: { a: 1, b: "2" } })).toEqual('{"a":1,"b":"2"}');
-  });
-
-  it("unescapes escaped sequences", function () {
-    const interp = $interpolate("\\{\\{expr\\}\\} {{expr}} \\{\\{expr\\}\\}");
-    expect(interp({ expr: "value" })).toEqual("{{expr}} value {{expr}}");
-  });
-
-  it("does not return function when flagged and no expressions", function () {
-    const interp = $interpolate("static content only", true);
-    expect(interp).toBeFalsy();
-  });
-
-  it("returns function when flagged and has expressions", function () {
-    const interp = $interpolate("has an {{expr}}", true);
-    expect(interp).not.toBeFalsy();
-  });
-
-  it("should return the interpolation object when there are no bindings and textOnly is undefined", () => {
-    const interpolateFn = $interpolate("some text");
-
-    expect(interpolateFn.exp).toBe("some text");
-    expect(interpolateFn.expressions).toEqual([]);
-
-    expect(interpolateFn({})).toBe("some text");
-  });
-
-  it("should return undefined when there are no bindings and textOnly is set to true", () => {
-    expect($interpolate("some text", true)).toBeUndefined();
-  });
-
-  it("should return undefined when there are bindings and strict is set to true", () => {
-    expect($interpolate("test {{foo}}", false, null, true)({})).toBeUndefined();
-  });
-
-  it("should suppress falsy objects", () => {
-    expect($interpolate("{{undefined}}")({})).toEqual("");
-    expect($interpolate("{{null}}")({})).toEqual("");
-    expect($interpolate("{{a.b}}")({})).toEqual("");
-  });
-
-  it("should jsonify objects", () => {
-    expect($interpolate("{{ {} }}")({})).toEqual("{}");
-    expect($interpolate("{{ true }}")({})).toEqual("true");
-    expect($interpolate("{{ false }}")({})).toEqual("false");
-  });
-
-  it("should use custom toString when present", () => {
-    const context = {
-      a: {
-        toString() {
-          return "foo";
-        },
-      },
-    };
-
-    expect($interpolate("{{ a }}")(context)).toEqual("foo");
-  });
-
-  it("should NOT use toString on array objects", () => {
-    expect($interpolate("{{a}}")({ a: [] })).toEqual("[]");
-  });
-
-  it("should NOT use toString on Date objects", () => {
-    const date = new Date(2014, 10, 10);
-    expect($interpolate("{{a}}")({ a: date })).toBe(JSON.stringify(date));
-    expect($interpolate("{{a}}")({ a: date })).not.toEqual(date.toString());
-  });
-
-  it("should return interpolation function", () => {
-    const interpolateFn = $interpolate("Hello {{name}}!");
-
-    expect(interpolateFn.exp).toBe("Hello {{name}}!");
-    expect(interpolateFn.expressions).toEqual(["name"]);
-
-    const scope = $rootScope.$new();
-    scope.name = "Bubu";
-
-    expect(interpolateFn(scope)).toBe("Hello Bubu!");
-  });
-
-  it("should ignore undefined model", () => {
-    expect($interpolate("Hello {{'World'}}{{foo}}")({})).toBe("Hello World");
-  });
-
-  it("should interpolate with undefined context", () => {
-    expect($interpolate("Hello, world!{{bloop}}")()).toBe("Hello, world!");
-  });
-
-  describe("interpolation escaping", () => {
-    let obj;
-    let $compile;
-    beforeEach(() => {
-      obj = { foo: "Hello", bar: "World" };
-      $compile = $injector.get("$compile");
-    });
-
-    it("uses a watch delegate", function () {
-      const interp = $interpolate("has an {{expr}}");
-      expect(interp.$$watchDelegate).toBeDefined();
-    });
-
-    it("correctly returns new value", async () => {
-      const interp = $interpolate("{{expr}}");
-      $rootScope.$watch("expr", () => {});
-      $rootScope.expr = 42;
-      await wait();
-      expect(interp($rootScope)).toEqual("42");
-    });
-
-    it("should support escaping interpolation signs", () => {
-      expect($interpolate("\\{\\{")(obj)).toBe("{{");
-      expect($interpolate("{{foo}} \\{\\{bar\\}\\}")(obj)).toBe(
-        "Hello {{bar}}",
-      );
-      expect($interpolate("\\{\\{foo\\}\\} {{bar}}")(obj)).toBe(
-        "{{foo}} World",
-      );
-    });
-
-    it("should unescape multiple expressions", () => {
-      expect($interpolate("\\{\\{foo\\}\\}\\{\\{bar\\}\\} {{foo}}")(obj)).toBe(
-        "{{foo}}{{bar}} Hello",
-      );
-      expect($interpolate("{{foo}}\\{\\{foo\\}\\}\\{\\{bar\\}\\}")(obj)).toBe(
-        "Hello{{foo}}{{bar}}",
-      );
-      expect($interpolate("\\{\\{foo\\}\\}{{foo}}\\{\\{bar\\}\\}")(obj)).toBe(
-        "{{foo}}Hello{{bar}}",
-      );
-      expect(
-        $interpolate("{{foo}}\\{\\{foo\\}\\}{{bar}}\\{\\{bar\\}\\}{{foo}}")(
-          obj,
-        ),
-      ).toBe("Hello{{foo}}World{{bar}}Hello");
-    });
-
-    it("should support escaping custom interpolation start/end symbols", () => {
-      angular
-        .module("customInterpolationApp", ["ng"])
-        .config(function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "[[";
-          $interpolateProvider.endSymbol = "]]";
-        });
-
-      $injector = createInjector(["customInterpolationApp"]);
-      $interpolate = $injector.get("$interpolate");
-
-      expect($interpolate("[[foo]] \\[\\[bar\\]\\]")(obj)).toBe(
-        "Hello [[bar]]",
-      );
-    });
-
-    it("should unescape incomplete escaped expressions", () => {
-      expect($interpolate("\\{\\{foo{{foo}}")(obj)).toBe("{{fooHello");
-      expect($interpolate("\\}\\}foo{{foo}}")(obj)).toBe("}}fooHello");
-      expect($interpolate("foo{{foo}}\\{\\{")(obj)).toBe("fooHello{{");
-      expect($interpolate("foo{{foo}}\\}\\}")(obj)).toBe("fooHello}}");
-    });
-
-    it("should not unescape markers within expressions", () => {
-      expect($interpolate('{{"\\\\{\\\\{Hello, world!\\\\}\\\\}"}}')(obj)).toBe(
-        "\\{\\{Hello, world!\\}\\}",
-      );
-      expect($interpolate('{{"\\{\\{Hello, world!\\}\\}"}}')(obj)).toBe(
-        "{{Hello, world!}}",
-      );
-      expect(() => {
-        $interpolate("{{\\{\\{foo\\}\\}}}")(obj);
-      }).toThrowError(/Lexer Error/);
-    });
-
-    it("allows configuring start and end symbols", function () {
-      const injector = createInjector([
-        "ng",
-        function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "FOO";
-          $interpolateProvider.endSymbol = "OOF";
-        },
-      ]);
-      const $interpolate = injector.get("$interpolate");
-      expect($interpolate.startSymbol()).toEqual("FOO");
-      expect($interpolate.endSymbol()).toEqual("OOF");
-    });
-
-    it("works with start and end symbols that differ from default", function () {
-      const injector = createInjector([
-        "ng",
-        function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "FOO";
-          $interpolateProvider.endSymbol = "OOF";
-        },
-      ]);
-      const $interpolate = injector.get("$interpolate");
-      const interpFn = $interpolate("FOOmyExprOOF");
-      expect(interpFn({ myExpr: 42 })).toEqual("42");
-    });
-
-    it("does not work with default symbols when reconfigured", function () {
-      const injector = createInjector([
-        "ng",
-        function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "FOO";
-          $interpolateProvider.endSymbol = "OOF";
-        },
-      ]);
-      const $interpolate = injector.get("$interpolate");
-      const interpFn = $interpolate("{{myExpr}}");
-      expect(interpFn({ myExpr: 42 })).toEqual("{{myExpr}}");
-    });
-
-    it("supports unescaping for reconfigured symbols", function () {
-      const injector = createInjector([
-        "ng",
-        function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "FOO";
-          $interpolateProvider.endSymbol = "OOF";
-        },
-      ]);
-      const $interpolate = injector.get("$interpolate");
-      const interpFn = $interpolate("\\F\\O\\OmyExpr\\O\\O\\F");
-      expect(interpFn({})).toEqual("FOOmyExprOOF");
-    });
-
-    // This test demonstrates that the web-server is responsible for escaping every single instance
-    // of interpolation start/end markers in an expression which they do not wish to evaluate,
-    // because AngularTS will not protect them from being evaluated (due to the added compleity
-    // and maintenance burden of context-sensitive escaping)
-    it("should evaluate expressions between escaped start/end symbols", () => {
-      expect($interpolate("\\{\\{Hello, {{bar}}!\\}\\}")(obj)).toBe(
-        "{{Hello, World!}}",
-      );
-    });
-  });
-
-  describe("interpolation callbacks", () => {
-    it("does not require a callback", async () => {
-      let text;
-      $rootScope.expr = 42;
-      const interp = $interpolate("{{expr}}");
-
-      text = interp($rootScope);
-
-      expect(text).toEqual("42");
-    });
-
-    it("correctly invokes callback when interpolated value changes", async () => {
-      let counter = 0;
-
-      const interp = $interpolate("{{expr}}");
-
-      interp($rootScope, (val) => {
-        counter++;
-      });
-
-      $rootScope.expr = 42;
-      await wait();
-      expect(counter).toEqual(2);
-
-      $rootScope.expr++;
-      await wait();
-      expect(counter).toEqual(3);
-    });
-
-    it("returns currently interpolated text", async () => {
-      let text;
-      $rootScope.expr = 42;
-      const interp = $interpolate("{{expr}}");
-
-      text = interp($rootScope, (val) => {
-        text = val;
-      });
-
-      expect(text).toEqual("42");
-    });
-
-    it("invokes callback with newly interpolated text", async () => {
-      let text;
-      const interp = $interpolate("{{expr}}");
-
-      interp($rootScope, (val) => {
-        text = val;
-      });
-
-      $rootScope.expr = 42;
-      await wait();
-      expect(text).toEqual("42");
-    });
-  });
-
-  describe("interpolating in a trusted context", () => {
-    let sce;
-    let errors = [];
-
-    beforeEach(() => {
-      angular
-        .module("customInterpolationApp", ["ng"])
-        .decorator("$exceptionHandler", () => {
-          return (exception) => {
-            errors.push(exception.message);
-          };
-        })
-        .config(function ($sceProvider) {
-          $sceProvider.enabled(true);
-        });
-
-      $injector = createInjector(["customInterpolationApp"]);
-      $interpolate = $injector.get("$interpolate");
-      $rootScope = $injector.get("$rootScope");
-      sce = $injector.get("$sce");
-    });
-
-    it("should NOT interpolate non-trusted expressions", async () => {
-      const scope = $rootScope.$new();
-      scope.foo = "foo";
-      await wait();
-      $interpolate("{{foo}}", true, sce.CSS)(scope);
-      expect(errors[0]).toMatch("unsafe value");
-    });
-
-    it("should interpolate trusted expressions in a regular context", () => {
-      const foo = sce.trustAsCss("foo");
-      expect($interpolate("{{foo}}", true)({ foo })).toBe("foo");
-    });
-
-    it("should interpolate trusted expressions in a specific trustedContext", () => {
-      const foo = sce.trustAsCss("foo");
-      expect($interpolate("{{foo}}", true, sce.CSS)({ foo })).toBe("foo");
-    });
-
-    // The concatenation of trusted values does not necessarily result in a trusted value.  (For
-    // instance, you can construct evil JS code by putting together pieces of JS strings that are by
-    // themselves safe to execute in isolation). Therefore, some contexts disable it, such as CSS.
-    it("should NOT interpolate trusted expressions with multiple parts", () => {
-      const foo = sce.trustAsCss("foo");
-      const bar = sce.trustAsCss("bar");
-      expect(() =>
-        $interpolate("{{foo}}{{bar}}", true, sce.CSS)({ foo, bar }),
-      ).toThrowError(/Error while interpolating/);
-    });
-  });
-
-  describe("provider", () => {
-    beforeEach(() => {
-      angular
-        .module("customInterpolationApp", ["ng"])
-        .config(function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "--";
-          $interpolateProvider.endSymbol = "--";
-        });
-
-      $injector = createInjector(["customInterpolationApp"]);
-      $interpolate = $injector.get("$interpolate");
-    });
-
-    it("should not get confused with same markers", () => {
-      expect($interpolate("---").expressions).toEqual([]);
-      expect($interpolate("----")({})).toEqual("");
-      expect($interpolate("--1--")({})).toEqual("1");
-    });
-  });
-
-  describe("parseBindings", () => {
-    it("should Parse Text With No Bindings", () => {
-      expect($interpolate("a").expressions).toEqual([]);
-    });
-
-    it("should Parse Empty Text", () => {
-      expect($interpolate("").expressions).toEqual([]);
-    });
-
-    it("should Parse Inner Binding", () => {
-      const interpolateFn = $interpolate("a{{b}}C");
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["b"]);
-      expect(interpolateFn({ b: 123 })).toEqual("a123C");
-    });
-
-    it("should Parse Ending Binding", () => {
-      const interpolateFn = $interpolate("a{{b}}");
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["b"]);
-      expect(interpolateFn({ b: 123 })).toEqual("a123");
-    });
-
-    it("should Parse Begging Binding", () => {
-      const interpolateFn = $interpolate("{{b}}c");
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["b"]);
-      expect(interpolateFn({ b: 123 })).toEqual("123c");
-    });
-
-    it("should Parse Loan Binding", () => {
-      const interpolateFn = $interpolate("{{b}}");
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["b"]);
-      expect(interpolateFn({ b: 123 })).toEqual("123");
-    });
-
-    it("should Parse Two Bindings", () => {
-      const interpolateFn = $interpolate("{{b}}{{c}}");
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["b", "c"]);
-      expect(interpolateFn({ b: 111, c: 222 })).toEqual("111222");
-    });
-
-    it("should Parse Two Bindings With Text In Middle", () => {
-      const interpolateFn = $interpolate("{{b}}x{{c}}");
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["b", "c"]);
-      expect(interpolateFn({ b: 111, c: 222 })).toEqual("111x222");
-    });
-
-    it("should Parse Multiline", () => {
-      const interpolateFn = $interpolate('"X\nY{{A\n+B}}C\nD"');
-      const { expressions } = interpolateFn;
-      expect(expressions).toEqual(["A\n+B"]);
-      expect(interpolateFn({ A: "aa", B: "bb" })).toEqual('"X\nYaabbC\nD"');
-    });
-  });
-
-  describe("isTrustedContext", () => {
-    it("should NOT interpolate a multi-part expression when isTrustedContext is RESOURCE_URL", () => {
-      const isTrustedContext = $sce.RESOURCE_URL;
-      expect(() => {
-        $interpolate("constant/{{var}}", true, isTrustedContext)("val");
-      }).toThrowError(/Can't interpolate:/);
-      expect(() => {
-        $interpolate("{{var}}/constant", true, isTrustedContext)("val");
-      }).toThrowError(/Can't interpolate:/);
-      expect(() => {
-        $interpolate("{{foo}}{{bar}}", true, isTrustedContext)("val");
-      }).toThrowError(/Can't interpolate:/);
-    });
-
-    it("should interpolate a multi-part expression when isTrustedContext is false", () => {
-      expect($interpolate("some/{{id}}")({})).toEqual("some/");
-      expect($interpolate("some/{{id}}")({ id: 1 })).toEqual("some/1");
-      expect($interpolate("{{foo}}{{bar}}")({ foo: 1, bar: 2 })).toEqual("12");
-    });
-
-    it("should interpolate a multi-part expression when isTrustedContext is URL", () => {
-      expect($interpolate("some/{{id}}", true, $sce.URL)({})).toEqual("some/");
-      expect($interpolate("some/{{id}}", true, $sce.URL)({ id: 1 })).toEqual(
-        "some/1",
-      );
-      expect(
-        $interpolate("{{foo}}{{bar}}", true, $sce.URL)({ foo: 1, bar: 2 }),
-      ).toEqual("12");
-    });
-
-    it("should interpolate and sanitize a multi-part expression when isTrustedContext is URL", () => {
-      expect($interpolate("some/{{id}}", true, $sce.URL)({})).toEqual("some/");
-      expect(
-        $interpolate("some/{{id}}", true, $sce.URL)({ id: "javascript:" }),
-      ).toEqual("some/javascript:");
-      expect(
-        $interpolate(
-          "{{foo}}{{bar}}",
-          true,
-          $sce.URL,
-        )({ foo: "javascript:", bar: "javascript:" }),
-      ).toEqual("unsafe:javascript:javascript:");
-    });
-  });
-
-  describe("startSymbol", () => {
-    beforeEach(() => {
-      angular
-        .module("customInterpolationApp", ["ng"])
-        .config(function ($interpolateProvider) {
-          expect($interpolateProvider.startSymbol).toBe("{{");
-          $interpolateProvider.startSymbol = "((";
-        });
-
-      $injector = createInjector(["customInterpolationApp"]);
-      $interpolate = $injector.get("$interpolate");
-    });
-
-    it("should expose the endSymbol in config phase", () => {
-      angular
-        .module("customInterpolationApp")
-        .config(function ($interpolateProvider) {
-          expect($interpolateProvider.startSymbol).toBe("((");
-        });
-    });
-
-    it("should expose the startSymbol in run phase", () => {
-      expect($interpolate.startSymbol()).toBe("((");
-    });
-
-    it("should not get confused by matching start and end symbols", () => {
-      angular
-        .module("customInterpolationApp", ["ng"])
-        .config(function ($interpolateProvider) {
-          $interpolateProvider.startSymbol = "--";
-          $interpolateProvider.endSymbol = "--";
-        });
-
-      $injector = createInjector(["customInterpolationApp"]);
-      $interpolate = $injector.get("$interpolate");
-
-      () => {
-        expect($interpolate("---").expressions).toEqual([]);
-        expect($interpolate("----")({})).toEqual("");
-        expect($interpolate("--1--")({})).toEqual("1");
-      };
-    });
-  });
-
-  describe("endSymbol", () => {
-    beforeEach(() => {
-      angular
-        .module("customInterpolationApp", ["ng"])
-        .config(function ($interpolateProvider) {
-          expect($interpolateProvider.endSymbol).toBe("}}");
-          $interpolateProvider.endSymbol = "))";
-        });
-
-      $injector = createInjector(["customInterpolationApp"]);
-      $interpolate = $injector.get("$interpolate");
-    });
-
-    it("should expose the endSymbol in config phase", () => {
-      angular
-        .module("customInterpolationApp")
-        .config(function ($interpolateProvider) {
-          expect($interpolateProvider.endSymbol).toBe("))");
-        });
-    });
-
-    it("should expose the endSymbol in run phase", () => {
-      expect($interpolate.endSymbol()).toBe("))");
-    });
-  });
-});

package/src/core/interpolate/interpolate.test.js

@@ -1,12 +0,0 @@
-import { test, expect } from "@playwright/test";
-
-const TEST_URL = "src/core/interpolate/interpolate.html";
-
-test("unit tests contain no errors", async ({ page }) => {
-  await page.goto(TEST_URL);
-  await page.content();
-  await page.waitForTimeout(1000);
-  await expect(page.locator(".jasmine-overall-result")).toHaveText(
-    / 0 failures/,
-  );
-});

package/src/core/parse/ast/ast-node.ts

@@ -1,81 +0,0 @@
-import { ASTType } from "../ast-type.js";
-
-/**
- * Represents a node in an Abstract Syntax Tree (AST).
- */
-export type ASTNode = {
-  /** The type of the AST node. */
-  type: ASTType;
-
-  /** The name of the identifier, if applicable. */
-  name?: string;
-
-  /** The kind of the property (e.g., 'init'). */
-  kind?: string;
-
-  /** The value of the node if it is a literal. */
-  value?: any;
-
-  /** The elements of an array node. */
-  elements?: ASTNode[];
-
-  /** The properties of an object node. */
-  properties?: ASTNode[];
-
-  /** The key of an object property. */
-  key?: ASTNode;
-
-  /** The left-hand side of a binary expression. */
-  left?: ASTNode;
-
-  /** The right-hand side of a binary expression. */
-  right?: ASTNode;
-
-  /** The argument of a unary expression. */
-  argument?: ASTNode;
-
-  /** The test expression of a conditional expression. */
-  test?: ASTNode;
-
-  /** The alternate expression of a conditional expression. */
-  alternate?: ASTNode;
-
-  /** The consequent expression of a conditional expression. */
-  consequent?: ASTNode;
-
-  /** The body of a program or block statement. */
-  body?: ASTNode[];
-
-  /** A list of expressions to observe in a program or block statement. */
-  toWatch?: ASTNode[];
-
-  /** The expression of an expression statement. */
-  expression?: ASTNode;
-
-  /** The callee of a call expression. */
-  callee?: ASTNode;
-
-  /** The arguments of a call expression. */
-  arguments?: ASTNode[];
-
-  /** Indicates if a unary operator is a prefix. */
-  prefix?: boolean;
-
-  /** The object of a member expression. */
-  object?: ASTNode;
-
-  /** The property of a member expression. */
-  property?: ASTNode;
-
-  /** Indicates if a member expression is computed. */
-  computed?: boolean;
-
-  /** The operator of a binary or logical expression. */
-  operator?: string;
-
-  /** Indicates if the expression should be filtered. */
-  filter?: boolean;
-
-  /** Indicates in node depends on non-shallow state of objects */
-  isPure?: boolean;
-};