@woosh/meep-engine 2.48.23 → 2.49.0

package/src/engine/reference/v2/Reference.js

@@ -6,39 +6,34 @@ import Signal from "../../../core/events/signal/Signal.js";
 export class Reference {
 
     /**
-     * @template T
+     *
+     * @type {Signal<this,T>}
+     * @private
      */
-    constructor() {
-
-        /**
-         *
-         * @type {Signal}
-         * @private
-         */
-        this.__onReleased = new Signal();
-
-        /**
-         *
-         * @type {T}
-         * @private
-         */
-        this.__value = null;
-
-
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__is_bound = false;
-    }
+    #onReleased = new Signal();
+
+    /**
+     *
+     * @type {T}
+     * @private
+     */
+    #value = null;
+
+
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    #is_bound = false;
+
 
     /**
      *
-     * @returns {Signal}
+     * @returns {Signal<this,T>}
      */
     get onReleased() {
-        return this.__onReleased;
+        return this.#onReleased;
     }
 
     /**
@@ -46,17 +41,17 @@ export class Reference {
      * @param {T} value
      */
     bind(value) {
-        if (value === this.__value) {
+        if (value === this.#value) {
             return;
         }
 
-        if (this.__is_bound) {
+        if (this.#is_bound) {
             throw new Error(`Reference is already bound, must release before binding to a new value`);
         }
 
-        this.__value = value;
+        this.#value = value;
 
-        this.__is_bound = true;
+        this.#is_bound = true;
     }
 
     /**
@@ -64,27 +59,28 @@ export class Reference {
      * @returns {T}
      */
     getValue() {
-        return this.__value;
+        return this.#value;
     }
 
     release() {
-        if (!this.__is_bound) {
+        if (!this.#is_bound) {
             // not bound
             return;
         }
 
-        const v = this.__value;
+        const v = this.#value;
 
         // prevent further usage of the reference
-        this.__value = null;
+        this.#value = null;
 
-        this.__is_bound = false;
+        this.#is_bound = false;
 
-        this.__onReleased.send2(this,v);
+        this.#onReleased.send2(this, v);
     }
 }
 
 /**
+ * Special NULL reference that can be used to indicate lack of reference
  * @readonly
  * @type {Readonly<Reference>}
  */

package/src/engine/sound/sopra/README.md

@@ -1 +1,7 @@
+## Sopra
+
+Object-oriented sound engine
+
+---
+
 Loosely based on concepts from FMOD and Wwise

package/src/generation/automata/CaveGeneratorCellularAutomata.js

@@ -5,7 +5,6 @@ import { CellularAutomata } from "./CellularAutomata.js";
 export class CaveGeneratorCellularAutomata extends CellularAutomata {
     step(data, width, height) {
 
-
         const maxY = height - 1;
         const maxX = width - 1;
 
@@ -21,20 +20,24 @@ export class CaveGeneratorCellularAutomata extends CellularAutomata {
                 const columnLeft = max2(x - 1, 0);
                 const columnRight = min2(x + 1, maxX);
 
-                //
+                // read top row
+                const topLeft = data[rowIndexTop + columnLeft];
                 const top = data[rowIndexTop + x];
-                const bottom = data[rowIndexBottom + x];
+                const topRight = data[rowIndexTop + columnRight];
+
+                // read middle row
                 const left = data[rowIndex + columnLeft];
+                const cellValue = data[cellIndex];
                 const right = data[rowIndex + columnRight];
-                //
-                const topLeft = data[rowIndexTop + columnLeft];
-                const topRight = data[rowIndexTop + columnRight];
+
+                // read bottom row
                 const bottomLeft = data[rowIndexBottom + columnLeft];
+                const bottom = data[rowIndexBottom + x];
                 const bottomRight = data[rowIndexBottom + columnRight];
 
                 //count neighbours
                 const neighbourSum = top + bottom + left + right + topLeft + topRight + bottomLeft + bottomRight;
-                const cellValue = data[cellIndex];
+
 
                 if (cellValue > 0) {
                     //cell is alive

package/src/generation/automata/CaveGeneratorCellularAutomata.spec.js

@@ -0,0 +1,12 @@
+import { CaveGeneratorCellularAutomata } from "./CaveGeneratorCellularAutomata.js";
+
+test("single cell execution", () => {
+    const automata = new CaveGeneratorCellularAutomata();
+
+    const array = new Uint8Array([0]);
+
+    automata.step(array, 1, 1);
+
+    // cell should stay dead, no live neighbours
+    expect(array[0]).toBe(0);
+});

package/src/generation/automata/CellularAutomata.js

@@ -1,10 +1,11 @@
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 
 export class CellularAutomata {
-    constructor() {
-
-        this.random = seededRandom(1);
-    }
+    /**
+     *
+     * @type {function(): number}
+     */
+    random = seededRandom(1);
 
     /**
      *

package/src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -86,6 +86,20 @@ export class CellFilterGaussianBlur extends CellFilter {
          * @private
          */
         this.__inv_kernel_total_power = 0;
+
+        /**
+         * Written by 'initialize' stage
+         * @type {number}
+         * @private
+         */
+        this.__local_u_scale = 0;
+
+        /**
+         * Written by 'initialize' stage
+         * @type {number}
+         * @private
+         */
+        this.__local_v_scale = 0;
     }
 
     initialize(grid, seed) {
@@ -105,6 +119,11 @@ export class CellFilterGaussianBlur extends CellFilter {
         // store inverse, to be able to use multiply instead of division in execution
         this.__inv_kernel_total_power = 1 / this.__kernel_total_power;
 
+
+        // precompute scaling for the sampling(execute) stage
+        this.__local_u_scale = this.size_x / (this.samples_x - 1);
+        this.__local_v_scale = this.size_y / (this.samples_y - 1);
+
         super.initialize(grid, seed);
     }
 
@@ -140,11 +159,8 @@ export class CellFilterGaussianBlur extends CellFilter {
         const half_samples_x = (samplesX - 1) * 0.5;
         const half_samples_y = (samplesY - 1) * 0.5;
 
-        const sizeX = this.size_x;
-        const sizeY = this.size_y;
-
-        const local_u_scale = sizeX / (samplesX - 1);
-        const local_v_scale = sizeY / (samplesY - 1);
+        const local_u_scale = this.__local_u_scale;
+        const local_v_scale = this.__local_v_scale;
 
         let sum = 0;
         let ix, iy = 0;
@@ -157,7 +173,7 @@ export class CellFilterGaussianBlur extends CellFilter {
         for (; iy < samplesY; iy++) {
             const local_y = iy - half_samples_y;
 
-            const offset_y = y + local_y * local_v_scale;
+            const sample_y = y + local_y * local_v_scale;
 
             const row_address = iy * i_samples_x;
 
@@ -165,13 +181,13 @@ export class CellFilterGaussianBlur extends CellFilter {
 
                 const local_x = ix - half_samples_x;
 
-                const offset_x = local_x * local_u_scale;
+                const sample_x = x + local_x * local_u_scale;
 
                 const power = kernel[row_address + ix];
 
-                const sourceValue = source.execute(grid, x + offset_x, offset_y, 0);
+                const source_value = source.execute(grid, sample_x, sample_y, 0);
 
-                const sample_contribution = sourceValue * power;
+                const sample_contribution = source_value * power;
 
                 sum += sample_contribution;
 

package/src/view/minimap/dom/MinimapCameraView.js

@@ -1,9 +1,9 @@
 import View from "../../View.js";
 import Vector3 from "../../../core/geom/Vector3.js";
-import { computePlaneRayIntersection } from "../../../core/geom/Plane.js";
 import ObservedValue from "../../../core/model/ObservedValue.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import SVG from "../../SVG.js";
+import { computePlaneRayIntersection } from "../../../core/geom/3d/plane/computePlaneRayIntersection.js";
 
 
 const rayContact = new SurfacePoint3();

package/src/core/geom/Plane.js

@@ -1,250 +0,0 @@
-/**
- * Created by Alex on 20/02/2017.
- */
-
-
-import { v3_dot } from "./v3_dot.js";
-
-/**
-
- Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the
- section 'Intersection of 2 Planes' and specifically the subsection
- (A) Direct Linear Equation
- @param {Plane} p1
- @param {Plane} p2
- @param {Vector3} point
- @param {Vector3} direction
- @returns {boolean}
- */
-export function computePlanePlaneIntersection(p1, p2, point, direction) {
-
-    // the cross product gives us the direction of the line at the intersection
-    // of the two planes, and gives us an easy way to check if the two planes
-    // are parallel - the cross product will have zero magnitude
-
-    direction.crossVectors(p1.normal, p2.normal);
-
-    const magnitude = direction.lengthSqr();
-
-    if (magnitude === 0) {
-        return false;
-    }
-
-    // now find a point on the intersection. We use the 'Direct Linear Equation'
-    // method described in the linked page, and we choose which coordinate
-    // to set as zero by seeing which has the largest absolute value in the
-    // directional vector
-
-    const X = Math.abs(direction.x);
-    const Y = Math.abs(direction.y);
-    const Z = Math.abs(direction.z);
-
-    if (Z >= X && Z >= Y) {
-        solveIntersectingPoint('z', 'x', 'y', p1, p2, point);
-    } else if (Y >= Z && Y >= X) {
-        solveIntersectingPoint('y', 'z', 'x', p1, p2, point);
-    } else {
-        solveIntersectingPoint('x', 'y', 'z', p1, p2, point);
-    }
-
-    return true;
-}
-
-/**
- *
- * @param {Vector3} out Result will be written here
- * @param {Vector3} origin Ray origin
- * @param {Vector3} direction Ray direction
- * @param {Vector3} normal Plane normal
- * @param {number} dist Plane distance
- * @returns {boolean} true if intersection is found, false otherwise
- */
-export function planeRayIntersection(out, origin, direction, normal, dist) {
-    return computePlaneRayIntersection(out, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, normal.x, normal.y, normal.z, dist)
-}
-
-/**
- *
- * @param {Vector3} out Result will be written here
- * @param {number} originX Ray origin
- * @param {number} originY Ray origin
- * @param {number} originZ Ray origin
- * @param {number} directionX Ray direction
- * @param {number} directionY Ray direction
- * @param {number} directionZ Ray direction
- * @param {number} normalX Plane normal
- * @param {number} normalY Plane normal
- * @param {number} normalZ Plane normal
- * @param {number} dist Plane distance
- * @returns {boolean} true if intersection is found, false otherwise
- */
-export function computePlaneRayIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
-
-    if (denom !== 0) {
-
-        const t = -p / denom;
-
-        if (t < 0) {
-            return false;
-        }
-
-        out.set(
-            directionX * t + originX,
-            directionY * t + originY,
-            directionZ * t + originZ
-        );
-
-        return true;
-
-    } else {
-
-        if (p === 0) {
-
-            out.set(originX, originY, originZ);
-
-            return true;
-
-        } else {
-
-            //no intersection
-            return false;
-
-        }
-
-    }
-}
-
-/**
- *
- * @param {Vector3} out Result will be written here
- * @param {number} originX Ray origin
- * @param {number} originY Ray origin
- * @param {number} originZ Ray origin
- * @param {number} directionX Ray direction
- * @param {number} directionY Ray direction
- * @param {number} directionZ Ray direction
- * @param {number} normalX Plane normal
- * @param {number} normalY Plane normal
- * @param {number} normalZ Plane normal
- * @param {number} dist Plane distance
- * @returns {boolean} true if intersection is found, false otherwise
- */
-export function computePlaneLineIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
-
-    if (denom !== 0) {
-
-        const t = -p / denom;
-
-        out.set(
-            directionX * t + originX,
-            directionY * t + originY,
-            directionZ * t + originZ
-        );
-
-        return true;
-
-    } else {
-
-        if (p === 0) {
-
-            out.set(originX, originY, originZ);
-
-            return true;
-
-        } else {
-
-            //no intersection
-            return false;
-
-        }
-
-    }
-}
-
-/**
- *
- * @param {Float32Array|number[]|vec3} result
- * @param {number} result_offset
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} normalX
- * @param {number} normalY
- * @param {number} normalZ
- * @param {number} dist
- * @returns {boolean}
- */
-export function plane3_computeLineSegmentIntersection(
-    result, result_offset,
-    x0, y0, z0,
-    x1, y1, z1,
-    normalX, normalY, normalZ, dist
-) {
-
-    const directionX = x1 - x0;
-    const directionY = y1 - y0;
-    const directionZ = z1 - z0;
-
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    if (denom === 0) {
-        return false;
-    }
-
-    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
-
-    const t = -p / denom;
-
-    if (t < 0 || t > 1) {
-        return false;
-    }
-
-    result[result_offset] = directionX * t + x0;
-    result[result_offset + 1] = directionY * t + y0;
-    result[result_offset + 2] = directionZ * t + z0;
-
-    return true;
-
-}
-
-/**
-
- This method helps finding a point on the intersection between two planes.
- Depending on the orientation of the planes, the problem could solve for the
- zero point on either the x, y or z axis
- * @param {string} zeroCoord
- * @param {string} A
- * @param {string} B
- * @param {THREE.Plane} p1
- * @param {THREE.Plane} p2
- * @param {Vector3} result
- */
-function solveIntersectingPoint(zeroCoord, A, B, p1, p2, result) {
-    const nP1 = p1.normal;
-
-    const a1 = nP1[A];
-    const b1 = nP1[B];
-    const d1 = p1.constant;
-
-    const nP2 = p2.normal;
-
-    const a2 = nP2[A];
-    const b2 = nP2[B];
-    const d2 = p2.constant;
-
-    const A0 = ((b2 * d1) - (b1 * d2)) / ((a1 * b2 - a2 * b1));
-    const B0 = ((a1 * d2) - (a2 * d1)) / ((a1 * b2 - a2 * b1));
-
-    result[zeroCoord] = 0;
-    result[A] = A0;
-    result[B] = B0;
-}

package/src/core/land/reactive/ReactiveLexer.js

@@ -1,158 +0,0 @@
-// Generated from app/src/lang/Reactive.g4 by ANTLR 4.6-SNAPSHOT
-import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
-import { LexerATNSimulator } from "antlr4ts/atn/LexerATNSimulator";
-import { Lexer } from "antlr4ts/Lexer";
-import * as Utils from "antlr4ts/misc/Utils";
-import { VocabularyImpl } from "antlr4ts/VocabularyImpl";
-
-export class ReactiveLexer extends Lexer {
-    // tslint:enable:no-trailing-whitespace
-    constructor(input) {
-        super(input);
-        this._interp = new LexerATNSimulator(ReactiveLexer._ATN, this);
-    }
-    // @Override
-    // @NotNull
-    get vocabulary() {
-        return ReactiveLexer.VOCABULARY;
-    }
-    // @Override
-    get grammarFileName() {
-        return "Reactive.g4";
-    }
-    // @Override
-    get ruleNames() {
-        return ReactiveLexer.ruleNames;
-    }
-    // @Override
-    get serializedATN() {
-        return ReactiveLexer._serializedATN;
-    }
-    // @Override
-    get modeNames() {
-        return ReactiveLexer.modeNames;
-    }
-    static get _ATN() {
-        if (!ReactiveLexer.__ATN) {
-            ReactiveLexer.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(ReactiveLexer._serializedATN));
-        }
-        return ReactiveLexer.__ATN;
-    }
-}
-ReactiveLexer.T__0 = 1;
-ReactiveLexer.T__1 = 2;
-ReactiveLexer.T__2 = 3;
-ReactiveLexer.Identifier = 4;
-ReactiveLexer.NonzeroDigit = 5;
-ReactiveLexer.DigitSequence = 6;
-ReactiveLexer.FractionalConstant = 7;
-ReactiveLexer.ExponentPart = 8;
-ReactiveLexer.PLUS = 9;
-ReactiveLexer.MINUS = 10;
-ReactiveLexer.MULTIPLY = 11;
-ReactiveLexer.DIVIDE = 12;
-ReactiveLexer.NOT = 13;
-ReactiveLexer.GT = 14;
-ReactiveLexer.GTE = 15;
-ReactiveLexer.LT = 16;
-ReactiveLexer.LTE = 17;
-ReactiveLexer.EQUALS = 18;
-ReactiveLexer.NOT_EQUALS = 19;
-ReactiveLexer.AND = 20;
-ReactiveLexer.OR = 21;
-ReactiveLexer.DOT = 22;
-ReactiveLexer.OPEN_BRACKET = 23;
-ReactiveLexer.CLOSED_BRACKET = 24;
-ReactiveLexer.Whitespace = 25;
-// tslint:disable:no-trailing-whitespace
-ReactiveLexer.modeNames = [
-    "DEFAULT_MODE",
-];
-ReactiveLexer.ruleNames = [
-    "T__0", "T__1", "T__2", "Identifier", "IdentifierNondigit", "Nondigit",
-    "Digit", "NonzeroDigit", "DigitSequence", "FractionalConstant", "Sign",
-    "ExponentPart", "PLUS", "MINUS", "MULTIPLY", "DIVIDE", "NOT", "GT", "GTE",
-    "LT", "LTE", "EQUALS", "NOT_EQUALS", "AND", "OR", "DOT", "OPEN_BRACKET",
-    "CLOSED_BRACKET", "Whitespace",
-];
-ReactiveLexer._LITERAL_NAMES = [
-    undefined, "'0'", "'true'", "'false'", undefined, undefined, undefined,
-    undefined, undefined, "'+'", "'-'", "'*'", "'/'", "'!'", "'>'", "'>='",
-    "'<'", "'<='", "'=='", "'!='", "'&&'", "'||'", "'.'", "'('", "')'",
-];
-ReactiveLexer._SYMBOLIC_NAMES = [
-    undefined, undefined, undefined, undefined, "Identifier", "NonzeroDigit",
-    "DigitSequence", "FractionalConstant", "ExponentPart", "PLUS", "MINUS",
-    "MULTIPLY", "DIVIDE", "NOT", "GT", "GTE", "LT", "LTE", "EQUALS", "NOT_EQUALS",
-    "AND", "OR", "DOT", "OPEN_BRACKET", "CLOSED_BRACKET", "Whitespace",
-];
-ReactiveLexer.VOCABULARY = new VocabularyImpl(ReactiveLexer._LITERAL_NAMES, ReactiveLexer._SYMBOLIC_NAMES, []);
-ReactiveLexer._serializedATN = "\x03\uAF6F\u8320\u479D\uB75C\u4880\u1605\u191C\uAB37\x02\x1B\xA4\b\x01" +
-    "\x04\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06" +
-    "\x04\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r" +
-    "\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t" +
-    "\x12\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t" +
-    "\x17\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t" +
-    "\x1C\x04\x1D\t\x1D\x04\x1E\t\x1E\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03" +
-    "\x03\x03\x03\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x05" +
-    "\x03\x05\x03\x05\x07\x05N\n\x05\f\x05\x0E\x05Q\v\x05\x03\x06\x03\x06\x03" +
-    "\x07\x03\x07\x03\b\x03\b\x03\t\x03\t\x03\n\x06\n\\\n\n\r\n\x0E\n]\x03" +
-    "\v\x05\va\n\v\x03\v\x03\v\x03\v\x03\v\x03\v\x05\vh\n\v\x03\f\x03\f\x03" +
-    "\r\x03\r\x05\rn\n\r\x03\r\x03\r\x03\r\x05\rs\n\r\x03\r\x05\rv\n\r\x03" +
-    "\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x11\x03\x11\x03\x12\x03" +
-    "\x12\x03\x13\x03\x13\x03\x14\x03\x14\x03\x14\x03\x15\x03\x15\x03\x16\x03" +
-    "\x16\x03\x16\x03\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18\x03\x19\x03" +
-    "\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1C\x03\x1C\x03" +
-    "\x1D\x03\x1D\x03\x1E\x06\x1E\x9F\n\x1E\r\x1E\x0E\x1E\xA0\x03\x1E\x03\x1E" +
-    "\x02\x02\x02\x1F\x03\x02\x03\x05\x02\x04\x07\x02\x05\t\x02\x06\v\x02\x02" +
-    "\r\x02\x02\x0F\x02\x02\x11\x02\x07\x13\x02\b\x15\x02\t\x17\x02\x02\x19" +
-    "\x02\n\x1B\x02\v\x1D\x02\f\x1F\x02\r!\x02\x0E#\x02\x0F%\x02\x10\'\x02" +
-    "\x11)\x02\x12+\x02\x13-\x02\x14/\x02\x151\x02\x163\x02\x175\x02\x187\x02" +
-    "\x199\x02\x1A;\x02\x1B\x03\x02\x07\x05\x02C\\aac|\x03\x022;\x03\x023;" +
-    "\x04\x02--//\x05\x02\v\f\x0E\x0F\"\"\xA8\x02\x03\x03\x02\x02\x02\x02\x05" +
-    "\x03\x02\x02\x02\x02\x07\x03\x02\x02\x02\x02\t\x03\x02\x02\x02\x02\x11" +
-    "\x03\x02\x02\x02\x02\x13\x03\x02\x02\x02\x02\x15\x03\x02\x02\x02\x02\x19" +
-    "\x03\x02\x02\x02\x02\x1B\x03\x02\x02\x02\x02\x1D\x03\x02\x02\x02\x02\x1F" +
-    "\x03\x02\x02\x02\x02!\x03\x02\x02\x02\x02#\x03\x02\x02\x02\x02%\x03\x02" +
-    "\x02\x02\x02\'\x03\x02\x02\x02\x02)\x03\x02\x02\x02\x02+\x03\x02\x02\x02" +
-    "\x02-\x03\x02\x02\x02\x02/\x03\x02\x02\x02\x021\x03\x02\x02\x02\x023\x03" +
-    "\x02\x02\x02\x025\x03\x02\x02\x02\x027\x03\x02\x02\x02\x029\x03\x02\x02" +
-    "\x02\x02;\x03\x02\x02\x02\x03=\x03\x02\x02\x02\x05?\x03\x02\x02\x02\x07" +
-    "D\x03\x02\x02\x02\tJ\x03\x02\x02\x02\vR\x03\x02\x02\x02\rT\x03\x02\x02" +
-    "\x02\x0FV\x03\x02\x02\x02\x11X\x03\x02\x02\x02\x13[\x03\x02\x02\x02\x15" +
-    "g\x03\x02\x02\x02\x17i\x03\x02\x02\x02\x19u\x03\x02\x02\x02\x1Bw\x03\x02" +
-    "\x02\x02\x1Dy\x03\x02\x02\x02\x1F{\x03\x02\x02\x02!}\x03\x02\x02\x02#" +
-    "\x7F\x03\x02\x02\x02%\x81\x03\x02\x02\x02\'\x83\x03\x02\x02\x02)\x86\x03" +
-    "\x02\x02\x02+\x88\x03\x02\x02\x02-\x8B\x03\x02\x02\x02/\x8E\x03\x02\x02" +
-    "\x021\x91\x03\x02\x02\x023\x94\x03\x02\x02\x025\x97\x03\x02\x02\x027\x99" +
-    "\x03\x02\x02\x029\x9B\x03\x02\x02\x02;\x9E\x03\x02\x02\x02=>\x072\x02" +
-    "\x02>\x04\x03\x02\x02\x02?@\x07v\x02\x02@A\x07t\x02\x02AB\x07w\x02\x02" +
-    "BC\x07g\x02\x02C\x06\x03\x02\x02\x02DE\x07h\x02\x02EF\x07c\x02\x02FG\x07" +
-    "n\x02\x02GH\x07u\x02\x02HI\x07g\x02\x02I\b\x03\x02\x02\x02JO\x05\r\x07" +
-    "\x02KN\x05\r\x07\x02LN\x05\x0F\b\x02MK\x03\x02\x02\x02ML\x03\x02\x02\x02" +
-    "NQ\x03\x02\x02\x02OM\x03\x02\x02\x02OP\x03\x02\x02\x02P\n\x03\x02\x02" +
-    "\x02QO\x03\x02\x02\x02RS\x05\r\x07\x02S\f\x03\x02\x02\x02TU\t\x02\x02" +
-    "\x02U\x0E\x03\x02\x02\x02VW\t\x03\x02\x02W\x10\x03\x02\x02\x02XY\t\x04" +
-    "\x02\x02Y\x12\x03\x02\x02\x02Z\\\x05\x0F\b\x02[Z\x03\x02\x02\x02\\]\x03" +
-    "\x02\x02\x02][\x03\x02\x02\x02]^\x03\x02\x02\x02^\x14\x03\x02\x02\x02" +
-    "_a\x05\x13\n\x02`_\x03\x02\x02\x02`a\x03\x02\x02\x02ab\x03\x02\x02\x02" +
-    "bc\x070\x02\x02ch\x05\x13\n\x02de\x05\x13\n\x02ef\x070\x02\x02fh\x03\x02" +
-    "\x02\x02g`\x03\x02\x02\x02gd\x03\x02\x02\x02h\x16\x03\x02\x02\x02ij\t" +
-    "\x05\x02\x02j\x18\x03\x02\x02\x02km\x07g\x02\x02ln\x05\x17\f\x02ml\x03" +
-    "\x02\x02\x02mn\x03\x02\x02\x02no\x03\x02\x02\x02ov\x05\x13\n\x02pr\x07" +
-    "G\x02\x02qs\x05\x17\f\x02rq\x03\x02\x02\x02rs\x03\x02\x02\x02st\x03\x02" +
-    "\x02\x02tv\x05\x13\n\x02uk\x03\x02\x02\x02up\x03\x02\x02\x02v\x1A\x03" +
-    "\x02\x02\x02wx\x07-\x02\x02x\x1C\x03\x02\x02\x02yz\x07/\x02\x02z\x1E\x03" +
-    "\x02\x02\x02{|\x07,\x02\x02| \x03\x02\x02\x02}~\x071\x02\x02~\"\x03\x02" +
-    "\x02\x02\x7F\x80\x07#\x02\x02\x80$\x03\x02\x02\x02\x81\x82\x07@\x02\x02" +
-    "\x82&\x03\x02\x02\x02\x83\x84\x07@\x02\x02\x84\x85\x07?\x02\x02\x85(\x03" +
-    "\x02\x02\x02\x86\x87\x07>\x02\x02\x87*\x03\x02\x02\x02\x88\x89\x07>\x02" +
-    "\x02\x89\x8A\x07?\x02\x02\x8A,\x03\x02\x02\x02\x8B\x8C\x07?\x02\x02\x8C" +
-    "\x8D\x07?\x02\x02\x8D.\x03\x02\x02\x02\x8E\x8F\x07#\x02\x02\x8F\x90\x07" +
-    "?\x02\x02\x900\x03\x02\x02\x02\x91\x92\x07(\x02\x02\x92\x93\x07(\x02\x02" +
-    "\x932\x03\x02\x02\x02\x94\x95\x07~\x02\x02\x95\x96\x07~\x02\x02\x964\x03" +
-    "\x02\x02\x02\x97\x98\x070\x02\x02\x986\x03\x02\x02\x02\x99\x9A\x07*\x02" +
-    "\x02\x9A8\x03\x02\x02\x02\x9B\x9C\x07+\x02\x02\x9C:\x03\x02\x02\x02\x9D" +
-    "\x9F\t\x06\x02\x02\x9E\x9D\x03\x02\x02\x02\x9F\xA0\x03\x02\x02\x02\xA0" +
-    "\x9E\x03\x02\x02\x02\xA0\xA1\x03\x02\x02\x02\xA1\xA2\x03\x02\x02\x02\xA2" +
-    "\xA3\b\x1E\x02\x02\xA3<\x03\x02\x02\x02\f\x02MO]`gmru\xA0\x03\b\x02\x02";