@maroonedog/luq 2.1.0 → 2.2.0

package/dist/runtime/field-rule-context.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldRuleContext = void 0;
+class FieldRuleContext {
+    constructor(root, indices, 
+    /** Built at compile time, relative to the subject this field reads from. */
+    ownPath, item, external) {
+        this.root = root;
+        this.indices = indices;
+        this.ownPath = ownPath;
+        this.item = item;
+        this.external = external;
+        /**
+         * The path once something has asked for it. `null` rather than `""` because
+         * the empty string is a real path — the root.
+         *
+         * It is remembered because the index stack underneath is MUTABLE and is
+         * popped when the element ends. A rule that kept its context and read `path`
+         * afterwards would otherwise see wherever the runner had moved on to.
+         * Reading it during the rule's own call — which is what every rule does —
+         * pins it.
+         */
+        this.rendered = null;
+    }
+    get path() {
+        const already = this.rendered;
+        if (already !== null)
+            return already;
+        const built = this.indices.renderFieldPath(this.ownPath);
+        this.rendered = built;
+        return built;
+    }
+    /**
+     * Serialising a context is a thing people do when they log a failure, and a
+     * prototype getter would silently drop `path` from the output. This pins the
+     * JSON shape to the four DECLARED members and, as a side effect, stops the
+     * internals above from reaching a log line.
+     */
+    toJSON() {
+        return {
+            root: this.root,
+            path: this.path,
+            item: this.item,
+            external: this.external,
+        };
+    }
+}
+exports.FieldRuleContext = FieldRuleContext;

package/dist/runtime/field-rule-context.mjs

@@ -0,0 +1,44 @@
+export class FieldRuleContext {
+    constructor(root, indices, 
+    /** Built at compile time, relative to the subject this field reads from. */
+    ownPath, item, external) {
+        this.root = root;
+        this.indices = indices;
+        this.ownPath = ownPath;
+        this.item = item;
+        this.external = external;
+        /**
+         * The path once something has asked for it. `null` rather than `""` because
+         * the empty string is a real path — the root.
+         *
+         * It is remembered because the index stack underneath is MUTABLE and is
+         * popped when the element ends. A rule that kept its context and read `path`
+         * afterwards would otherwise see wherever the runner had moved on to.
+         * Reading it during the rule's own call — which is what every rule does —
+         * pins it.
+         */
+        this.rendered = null;
+    }
+    get path() {
+        const already = this.rendered;
+        if (already !== null)
+            return already;
+        const built = this.indices.renderFieldPath(this.ownPath);
+        this.rendered = built;
+        return built;
+    }
+    /**
+     * Serialising a context is a thing people do when they log a failure, and a
+     * prototype getter would silently drop `path` from the output. This pins the
+     * JSON shape to the four DECLARED members and, as a side effect, stops the
+     * internals above from reaching a log line.
+     */
+    toJSON() {
+        return {
+            root: this.root,
+            path: this.path,
+            item: this.item,
+            external: this.external,
+        };
+    }
+}

package/dist/runtime/index-stack.d.ts

@@ -1,11 +1,30 @@
-import type { PathSegment } from "../path/path-segment.types";
 export declare class IndexStack {
-    private readonly prefixes;
+    private readonly nodePaths;
     private readonly openIndices;
+    /**
+     * The rendered prefix, or `null` when it has not been asked for since the
+     * last push or pop. `null` and not `""` because the empty string is a real
+     * answer — the root.
+     *
+     * Invalidating rather than recomputing on push is the point: an element that
+     * raises no issue never renders its own prefix at all.
+     */
+    private currentPrefix;
     /** How many array levels are currently open. */
     get depth(): number;
     /** The open indices, outermost first: `[0, 2]` inside `grid[0][2]`. */
     get indices(): readonly number[];
+    /**
+     * The prefix for the currently open frames — `""` when none are open,
+     * `items[0]` inside one, `grid[0][2]` inside two.
+     *
+     * Indexed, never `nodePaths[nodePaths.length - 1]`. That expression at
+     * depth 0 is `nodePaths[-1]`, which is not an element read at all: -1 is
+     * outside the array, so V8 falls back to a named-property lookup and walks
+     * the prototype chain. The `prefix` getter used to be written that way and
+     * it took 12% of the array shape's self time.
+     */
+    private readTop;
     /** `""` at the root, `items[0]` inside the first element of `items`. */
     get prefix(): string;
     /**
@@ -21,8 +40,14 @@ export declare class IndexStack {
     push(nodePath: string, index: number): void;
     /** An unbalanced pop means a runner lost track of its own nesting. */
     pop(): void;
-    /** The issue path of a field read from the subject at the current level. */
-    renderFieldPath(template: readonly PathSegment[]): string;
+    /**
+     * The issue path of a field read from the subject at the current level.
+     *
+     * `renderedPath` was built once, at compile time. This used to walk the
+     * template on every call, which for an array meant rebuilding the same
+     * string once per element.
+     */
+    renderFieldPath(renderedPath: string): string;
 }
 /** `""` is the root path, so it never contributes a separator dot. */
 export declare function joinIssuePath(prefix: string, own: string): string;

package/dist/runtime/index-stack.js

@@ -1,19 +1,47 @@
 "use strict";
+// ===========================================================================
+// L5  src/runtime/index-stack.ts
+// Where the runtime currently is, expressed as a concrete issue path.
+//
+// An issue path must read `items[0].name`, never the declaration pattern
+// `items[*].name`. The legacy tree carried indices two different ways — the
+// nested-array processor threaded them through its own recursion while
+// validator-factory fell back to `error.path || elementPath` — which is how
+// the pattern string leaked into user-visible errors. There is one stack here
+// and every path a runner reports comes out of it.
+//
+// A CompiledField's template is RELATIVE to the subject it reads from, so an
+// element field of `items[*]` has the template `name` and could never render
+// `items[0].name` on its own. The array runner pushes the enclosing node and
+// the index; the stack renders the prefix.
+//
+// The prefix is rendered ON DEMAND and remembered until the next push or pop.
+// Entering used to build `items[0]` eagerly, which is one string per element
+// that nothing reads unless a rule fails — and now nothing reads it even then
+// until FieldRuleContext is asked for its path. Entering therefore costs two
+// pushes and one assignment, and the first field that asks pays the render.
+//
+// It is deliberately MUTABLE and pushed/popped around an element loop: one
+// stack lives for one validate() call, and 10k elements must not allocate 10k
+// index arrays. It is also why FieldRuleContext remembers the path it built —
+// this stack has moved on by the time a retained context could read it.
+// ===========================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexStack = void 0;
 exports.joinIssuePath = joinIssuePath;
-const format_issue_path_1 = require("../path/format-issue-path");
-/**
- * A compiled template never contains a wildcard (createValueReader rejects
- * one), so rendering it needs no index. Passing none is what makes a stray
- * wildcard template throw here instead of silently rendering a second copy of
- * an index this stack has already written into the prefix.
- */
-const NO_INDICES = Object.freeze([]);
 class IndexStack {
     constructor() {
-        this.prefixes = [];
+        this.nodePaths = [];
         this.openIndices = [];
+        /**
+         * The rendered prefix, or `null` when it has not been asked for since the
+         * last push or pop. `null` and not `""` because the empty string is a real
+         * answer — the root.
+         *
+         * Invalidating rather than recomputing on push is the point: an element that
+         * raises no issue never renders its own prefix at all.
+         */
+        this.currentPrefix = null;
     }
     /** How many array levels are currently open. */
     get depth() {
@@ -23,9 +51,34 @@ class IndexStack {
     get indices() {
         return this.openIndices;
     }
+    /**
+     * The prefix for the currently open frames — `""` when none are open,
+     * `items[0]` inside one, `grid[0][2]` inside two.
+     *
+     * Indexed, never `nodePaths[nodePaths.length - 1]`. That expression at
+     * depth 0 is `nodePaths[-1]`, which is not an element read at all: -1 is
+     * outside the array, so V8 falls back to a named-property lookup and walks
+     * the prototype chain. The `prefix` getter used to be written that way and
+     * it took 12% of the array shape's self time.
+     */
+    readTop() {
+        const already = this.currentPrefix;
+        if (already !== null)
+            return already;
+        let built = "";
+        for (let i = 0; i < this.nodePaths.length; i += 1) {
+            const nodePath = this.nodePaths[i];
+            const index = this.openIndices[i];
+            if (nodePath === undefined || index === undefined)
+                continue;
+            built = `${joinIssuePath(built, nodePath)}[${index}]`;
+        }
+        this.currentPrefix = built;
+        return built;
+    }
     /** `""` at the root, `items[0]` inside the first element of `items`. */
     get prefix() {
-        return this.prefixes[this.prefixes.length - 1] ?? "";
+        return this.readTop();
     }
     /**
      * Enters element `index` of an array node. `nodePath` is the node's own path
@@ -41,20 +94,28 @@ class IndexStack {
         if (!Number.isInteger(index) || index < 0) {
             throw new RangeError(`an array index must be a non-negative integer, received ${String(index)}`);
         }
-        this.prefixes.push(`${joinIssuePath(this.prefix, nodePath)}[${index}]`);
+        this.nodePaths.push(nodePath);
         this.openIndices.push(index);
+        this.currentPrefix = null;
     }
     /** An unbalanced pop means a runner lost track of its own nesting. */
     pop() {
         if (this.openIndices.length === 0) {
             throw new RangeError("popped an array index that was never pushed");
         }
-        this.prefixes.pop();
+        this.nodePaths.pop();
         this.openIndices.pop();
+        this.currentPrefix = null;
     }
-    /** The issue path of a field read from the subject at the current level. */
-    renderFieldPath(template) {
-        return joinIssuePath(this.prefix, (0, format_issue_path_1.formatIssuePath)(template, NO_INDICES));
+    /**
+     * The issue path of a field read from the subject at the current level.
+     *
+     * `renderedPath` was built once, at compile time. This used to walk the
+     * template on every call, which for an array meant rebuilding the same
+     * string once per element.
+     */
+    renderFieldPath(renderedPath) {
+        return joinIssuePath(this.readTop(), renderedPath);
     }
 }
 exports.IndexStack = IndexStack;

package/dist/runtime/index-stack.mjs

@@ -1,15 +1,43 @@
-import { formatIssuePath } from "../path/format-issue-path.mjs";
-/**
- * A compiled template never contains a wildcard (createValueReader rejects
- * one), so rendering it needs no index. Passing none is what makes a stray
- * wildcard template throw here instead of silently rendering a second copy of
- * an index this stack has already written into the prefix.
- */
-const NO_INDICES = Object.freeze([]);
+// ===========================================================================
+// L5  src/runtime/index-stack.ts
+// Where the runtime currently is, expressed as a concrete issue path.
+//
+// An issue path must read `items[0].name`, never the declaration pattern
+// `items[*].name`. The legacy tree carried indices two different ways — the
+// nested-array processor threaded them through its own recursion while
+// validator-factory fell back to `error.path || elementPath` — which is how
+// the pattern string leaked into user-visible errors. There is one stack here
+// and every path a runner reports comes out of it.
+//
+// A CompiledField's template is RELATIVE to the subject it reads from, so an
+// element field of `items[*]` has the template `name` and could never render
+// `items[0].name` on its own. The array runner pushes the enclosing node and
+// the index; the stack renders the prefix.
+//
+// The prefix is rendered ON DEMAND and remembered until the next push or pop.
+// Entering used to build `items[0]` eagerly, which is one string per element
+// that nothing reads unless a rule fails — and now nothing reads it even then
+// until FieldRuleContext is asked for its path. Entering therefore costs two
+// pushes and one assignment, and the first field that asks pays the render.
+//
+// It is deliberately MUTABLE and pushed/popped around an element loop: one
+// stack lives for one validate() call, and 10k elements must not allocate 10k
+// index arrays. It is also why FieldRuleContext remembers the path it built —
+// this stack has moved on by the time a retained context could read it.
+// ===========================================================================
 export class IndexStack {
     constructor() {
-        this.prefixes = [];
+        this.nodePaths = [];
         this.openIndices = [];
+        /**
+         * The rendered prefix, or `null` when it has not been asked for since the
+         * last push or pop. `null` and not `""` because the empty string is a real
+         * answer — the root.
+         *
+         * Invalidating rather than recomputing on push is the point: an element that
+         * raises no issue never renders its own prefix at all.
+         */
+        this.currentPrefix = null;
     }
     /** How many array levels are currently open. */
     get depth() {
@@ -19,9 +47,34 @@ export class IndexStack {
     get indices() {
         return this.openIndices;
     }
+    /**
+     * The prefix for the currently open frames — `""` when none are open,
+     * `items[0]` inside one, `grid[0][2]` inside two.
+     *
+     * Indexed, never `nodePaths[nodePaths.length - 1]`. That expression at
+     * depth 0 is `nodePaths[-1]`, which is not an element read at all: -1 is
+     * outside the array, so V8 falls back to a named-property lookup and walks
+     * the prototype chain. The `prefix` getter used to be written that way and
+     * it took 12% of the array shape's self time.
+     */
+    readTop() {
+        const already = this.currentPrefix;
+        if (already !== null)
+            return already;
+        let built = "";
+        for (let i = 0; i < this.nodePaths.length; i += 1) {
+            const nodePath = this.nodePaths[i];
+            const index = this.openIndices[i];
+            if (nodePath === undefined || index === undefined)
+                continue;
+            built = `${joinIssuePath(built, nodePath)}[${index}]`;
+        }
+        this.currentPrefix = built;
+        return built;
+    }
     /** `""` at the root, `items[0]` inside the first element of `items`. */
     get prefix() {
-        return this.prefixes[this.prefixes.length - 1] ?? "";
+        return this.readTop();
     }
     /**
      * Enters element `index` of an array node. `nodePath` is the node's own path
@@ -37,20 +90,28 @@ export class IndexStack {
         if (!Number.isInteger(index) || index < 0) {
             throw new RangeError(`an array index must be a non-negative integer, received ${String(index)}`);
         }
-        this.prefixes.push(`${joinIssuePath(this.prefix, nodePath)}[${index}]`);
+        this.nodePaths.push(nodePath);
         this.openIndices.push(index);
+        this.currentPrefix = null;
     }
     /** An unbalanced pop means a runner lost track of its own nesting. */
     pop() {
         if (this.openIndices.length === 0) {
             throw new RangeError("popped an array index that was never pushed");
         }
-        this.prefixes.pop();
+        this.nodePaths.pop();
         this.openIndices.pop();
+        this.currentPrefix = null;
     }
-    /** The issue path of a field read from the subject at the current level. */
-    renderFieldPath(template) {
-        return joinIssuePath(this.prefix, formatIssuePath(template, NO_INDICES));
+    /**
+     * The issue path of a field read from the subject at the current level.
+     *
+     * `renderedPath` was built once, at compile time. This used to walk the
+     * template on every call, which for an array meant rebuilding the same
+     * string once per element.
+     */
+    renderFieldPath(renderedPath) {
+        return joinIssuePath(this.readTop(), renderedPath);
     }
 }
 /** `""` is the root path, so it never contributes a separator dot. */

package/dist/runtime/run-array-node.js

@@ -19,11 +19,8 @@ exports.runArrayNodes = runArrayNodes;
 // `grid[0][2].name` and never the declaration pattern.
 // ===========================================================================
 const types_1 = require("../types");
-const format_issue_path_1 = require("../path/format-issue-path");
 const run_field_1 = require("./run-field");
 const output_writer_1 = require("./output-writer");
-/** A node template never contains a wildcard: the grouping cut it off. */
-const NO_INDICES = Object.freeze([]);
 /**
  * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
  * no output. Zipping by index needs no lookup and no identity check, because
@@ -57,16 +54,27 @@ function runArrayNode(node, subject, context, target) {
     return target.write(subject, rebuilt);
 }
 function runElements(node, array, context, target) {
-    const nodePath = (0, format_issue_path_1.formatIssuePath)(node.template, NO_INDICES);
+    const nodePath = node.renderedPath;
     const elementSink = context.sink.forArrayElements();
     const nested = target === undefined ? output_writer_1.NO_WRITE_TARGETS : target.nested;
+    // 要素コンテキストはノードごとに一つ。7つの成員のうち要素ごとに変わるのは
+    // `item` だけで、残る6つは validate() 一回のあいだ、あるいはこのノードの
+    // あいだ動かない。毎要素で組み直していたのは、動かないものを動くものと
+    // 同じ場所に置いていたからにすぎない。**プラグインには渡らない** —
+    // プラグインが見るのは runField が組む RuleContext で、そちらは `item` を
+    // 都度読み直すので、この使い回しは外から観測できない。
+    const elementContext = {
+        root: context.root,
+        sink: elementSink,
+        indices: context.indices,
+        shouldApplyTransforms: context.shouldApplyTransforms,
+        runRecursion: context.runRecursion,
+        item: undefined,
+        external: context.external,
+    };
     let rebuilt = array;
     for (let index = 0; index < array.length; index += 1) {
-        const elementContext = {
-            ...context,
-            sink: elementSink,
-            item: describeItem(array, index),
-        };
+        elementContext.item = describeItem(array, index);
         context.indices.push(nodePath, index);
         const element = runNested(node, runElementFields(node, array[index], elementContext), elementContext, nested);
         context.indices.pop();
@@ -84,7 +92,11 @@ function runNested(node, element, elementContext, nested) {
 }
 function runElementFields(node, element, elementContext) {
     let current = element;
-    for (const field of node.elementFields) {
+    const fields = node.elementFields;
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i];
+        if (field === undefined)
+            continue;
         const outcome = (0, run_field_1.runField)(field, current, elementContext);
         current = (0, output_writer_1.writeFieldValue)(field, current, outcome, elementContext.shouldApplyTransforms);
         if (elementContext.sink.shouldStopPlan())

package/dist/runtime/run-array-node.mjs

@@ -16,11 +16,8 @@
 // `grid[0][2].name` and never the declaration pattern.
 // ===========================================================================
 import { isArray } from "../types/index.mjs";
-import { formatIssuePath } from "../path/format-issue-path.mjs";
 import { runField } from "./run-field.mjs";
 import { NO_WRITE_TARGETS, replaceElement, writeFieldValue, } from "./output-writer.mjs";
-/** A node template never contains a wildcard: the grouping cut it off. */
-const NO_INDICES = Object.freeze([]);
 /**
  * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
  * no output. Zipping by index needs no lookup and no identity check, because
@@ -54,16 +51,27 @@ function runArrayNode(node, subject, context, target) {
     return target.write(subject, rebuilt);
 }
 function runElements(node, array, context, target) {
-    const nodePath = formatIssuePath(node.template, NO_INDICES);
+    const nodePath = node.renderedPath;
     const elementSink = context.sink.forArrayElements();
     const nested = target === undefined ? NO_WRITE_TARGETS : target.nested;
+    // 要素コンテキストはノードごとに一つ。7つの成員のうち要素ごとに変わるのは
+    // `item` だけで、残る6つは validate() 一回のあいだ、あるいはこのノードの
+    // あいだ動かない。毎要素で組み直していたのは、動かないものを動くものと
+    // 同じ場所に置いていたからにすぎない。**プラグインには渡らない** —
+    // プラグインが見るのは runField が組む RuleContext で、そちらは `item` を
+    // 都度読み直すので、この使い回しは外から観測できない。
+    const elementContext = {
+        root: context.root,
+        sink: elementSink,
+        indices: context.indices,
+        shouldApplyTransforms: context.shouldApplyTransforms,
+        runRecursion: context.runRecursion,
+        item: undefined,
+        external: context.external,
+    };
     let rebuilt = array;
     for (let index = 0; index < array.length; index += 1) {
-        const elementContext = {
-            ...context,
-            sink: elementSink,
-            item: describeItem(array, index),
-        };
+        elementContext.item = describeItem(array, index);
         context.indices.push(nodePath, index);
         const element = runNested(node, runElementFields(node, array[index], elementContext), elementContext, nested);
         context.indices.pop();
@@ -81,7 +89,11 @@ function runNested(node, element, elementContext, nested) {
 }
 function runElementFields(node, element, elementContext) {
     let current = element;
-    for (const field of node.elementFields) {
+    const fields = node.elementFields;
+    for (let i = 0; i < fields.length; i += 1) {
+        const field = fields[i];
+        if (field === undefined)
+            continue;
         const outcome = runField(field, current, elementContext);
         current = writeFieldValue(field, current, outcome, elementContext.shouldApplyTransforms);
         if (elementContext.sink.shouldStopPlan())

package/dist/runtime/run-field.js

@@ -3,19 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIELD_VALUE_UNCHANGED = void 0;
 exports.runField = runField;
 const create_issue_1 = require("./create-issue");
+const field_rule_context_1 = require("./field-rule-context");
 const decide_presence_1 = require("./decide-presence");
 /** Shared, frozen, never re-assigned: the common answer allocates nothing. */
 exports.FIELD_VALUE_UNCHANGED = Object.freeze({
     hasWriteBack: false,
 });
 function runField(field, subject, context) {
-    const path = context.indices.renderFieldPath(field.template);
-    const ruleContext = {
-        root: context.root,
-        path,
-        item: context.item,
-        external: context.external,
-    };
+    const ruleContext = new field_rule_context_1.FieldRuleContext(context.root, context.indices, field.renderedPath, context.item, context.external);
     const read = field.read(subject);
     const value = applyDefault(field, read, context.root);
     if (!(0, decide_presence_1.decidePresence)(field, value, ruleContext, context.sink)) {
@@ -47,24 +42,55 @@ function applyDefault(field, value, root) {
 }
 /** A closed gate ends the field successfully: no check, no transform. */
 function openGates(field, value, ruleContext) {
-    for (const gate of field.gates) {
+    // 添字ループである。for-of ではない。ここが回るのはコンパイル済みの
+    // 凍結配列で、凍結配列は V8 では PACKED_FROZEN_ELEMENTS になり、配列
+    // イテレータの高速化パスから外れる — イテレータと IteratorResult が
+    // 消去されず、要素×フィールドの回数だけ確保される。配列シェイプでは
+    // それだけで全ゴミの 45〜54% を占めていた (独立に5通りの改変で -45%
+    // 〜 -54%)。凍結は落とさない: コンパイル層の不変条件であり、凍結を
+    // 外しても添字ループより速くはならない。
+    const gates = field.gates;
+    for (let i = 0; i < gates.length; i += 1) {
+        const gate = gates[i];
+        if (gate === undefined)
+            continue;
         if (!gate.shouldRun(value, ruleContext))
             return false;
     }
     return true;
 }
+/**
+ * 失敗したときだけ通る側。ループ本体から出してある。
+ *
+ * runChecks はバイトコードで 302 バイトあり、TurboFan の呼び出し先
+ * インライン予算 (既定で累計 920 バイト) の最大の落選候補として
+ * --trace-turbo-inlining に名指しされていた。その 302 バイトの大半が、
+ * 受理された値では一度も走らない issue の組み立てである。ここへ出すと
+ * 残るループ本体が縮み、受理パスで 6.4% 速くなった。
+ *
+ * 中断の判定はここに含めない。issue を足したあとに shouldStopField を
+ * 見るという順序が abortEarlyOnEachField の意味そのものなので、呼び出し側に
+ * 並べて置いておく。
+ */
+function reportCheckFailure(check, detail, value, ruleContext, context) {
+    context.sink.add((0, create_issue_1.createIssue)({
+        path: ruleContext.path,
+        code: check.code,
+        severity: check.severity,
+        value,
+        render: (ctx) => check.describe(detail, ctx),
+    }));
+}
 function runChecks(field, value, ruleContext, context, mark) {
-    for (const check of field.checks) {
+    const checks = field.checks;
+    for (let i = 0; i < checks.length; i += 1) {
+        const check = checks[i];
+        if (check === undefined)
+            continue;
         const outcome = check.run(value, ruleContext);
         if (outcome.ok)
             continue;
-        context.sink.add((0, create_issue_1.createIssue)({
-            path: ruleContext.path,
-            code: check.code,
-            severity: check.severity,
-            value,
-            render: (ctx) => check.describe(outcome.detail, ctx),
-        }));
+        reportCheckFailure(check, outcome.detail, value, ruleContext, context);
         if (context.sink.shouldStopField(mark))
             return;
     }
@@ -75,7 +101,11 @@ function runTransforms(field, value, ruleContext, context, mark) {
         return value;
     }
     let current = value;
-    for (const transform of field.transforms) {
+    const transforms = field.transforms;
+    for (let i = 0; i < transforms.length; i += 1) {
+        const transform = transforms[i];
+        if (transform === undefined)
+            continue;
         current = transform.apply(current, ruleContext);
     }
     return current;