bard-legends-framework 0.9.6 → 0.10.0

package/dist/utilities/libraries/path-finder/path-finder.js

@@ -1,123 +1,127 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PathFinder = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const binary_heap_1 = require("../binary-heap/binary-heap");
+const helpers_lib_1 = require('helpers-lib');
+const binary_heap_1 = require('../binary-heap/binary-heap');
 const DIRECTIONS = [
-    { x: -1, y: -1 },
-    { x: -1, y: 0 },
-    { x: -1, y: 1 },
-    { x: 0, y: -1 },
-    { x: 0, y: 1 },
-    { x: 1, y: -1 },
-    { x: 1, y: 0 },
-    { x: 1, y: 1 }
+  { x: -1, y: -1 },
+  { x: -1, y: 0 },
+  { x: -1, y: 1 },
+  { x: 0, y: -1 },
+  { x: 0, y: 1 },
+  { x: 1, y: -1 },
+  { x: 1, y: 0 },
+  { x: 1, y: 1 }
 ];
 class Node {
-    constructor(position, distanceFromStart, distanceToEnd, parent = undefined) {
-        this.position = position;
-        this.distanceFromStart = distanceFromStart;
-        this.distanceToEnd = distanceToEnd;
-        this.parent = parent;
-        this.closed = false;
-    }
-    get pathLength() {
-        return this.distanceFromStart + this.distanceToEnd;
-    }
-    isEqual(targetPosition) {
-        return this.position.x === targetPosition.x && this.position.y === targetPosition.y;
-    }
-    createSolutionPath(directPathAvailable) {
-        let path = [this.position];
-        let current = this.parent;
-        while (current !== undefined) {
-            path.push(current.position);
-            current = current.parent;
-        }
-        path.reverse();
-        return { directPathAvailable, path };
-    }
-    getDistance(targetPosition) {
-        return helpers_lib_1.Vector.getDistance(this.position, targetPosition);
+  constructor(position, distanceFromStart, distanceToEnd, parent = undefined) {
+    this.position = position;
+    this.distanceFromStart = distanceFromStart;
+    this.distanceToEnd = distanceToEnd;
+    this.parent = parent;
+    this.closed = false;
+  }
+  get pathLength() {
+    return this.distanceFromStart + this.distanceToEnd;
+  }
+  isEqual(targetPosition) {
+    return this.position.x === targetPosition.x && this.position.y === targetPosition.y;
+  }
+  createSolutionPath(directPathAvailable) {
+    const path = [this.position];
+    let current = this.parent;
+    while (current !== undefined) {
+      path.push(current.position);
+      current = current.parent;
     }
+    path.reverse();
+    return { directPathAvailable, path };
+  }
+  getDistance(targetPosition) {
+    return helpers_lib_1.Vector.getDistance(this.position, targetPosition);
+  }
 }
 class Grid {
-    constructor(grid, startingPosition) {
-        this.grid = grid;
-        this.startingPosition = startingPosition;
-        this.nodes = new Map();
-        this.openMinBinaryHeap = new binary_heap_1.BinaryHeap('min');
-        this.closedSet = [];
-        this.width = grid[0].length;
-        this.height = grid.length;
-        let startingNode = new Node(this.startingPosition, 0, Number.MAX_SAFE_INTEGER);
-        this.openMinBinaryHeap.add(startingNode.pathLength, startingNode);
-    }
-    get hasOpenNodes() {
-        return this.openMinBinaryHeap.size > 0;
-    }
-    getNeighbors(node) {
-        return DIRECTIONS.map(direction => ({ x: node.position.x + direction.x, y: node.position.y + direction.y }))
-            .filter(neighborPosition => this.isPositionInsideGrid(neighborPosition) && this.isWalkable(neighborPosition))
-            .map(neighborPosition => this.nodes.get(neighborPosition.x)?.get(neighborPosition.y) || this.createNewNode(neighborPosition));
-    }
-    popLowestPathCostNode() {
-        let lowestPathNode = this.openMinBinaryHeap.pop();
-        this.openMinBinaryHeap.delete(lowestPathNode);
-        lowestPathNode.closed = true;
-        this.closedSet.push(lowestPathNode);
-        return lowestPathNode;
-    }
-    getBestClosedNode() {
-        return this.closedSet.reduce((prev, current) => (prev.distanceToEnd < current.distanceToEnd ? prev : current));
-    }
-    changeNodeCost(node, distanceFromStart, targetPosition, newParent) {
-        this.openMinBinaryHeap.delete(node);
-        node.distanceFromStart = distanceFromStart;
-        node.distanceToEnd = node.getDistance(targetPosition);
-        node.parent = newParent;
-        this.openMinBinaryHeap.add(node.pathLength, node);
-    }
-    createNewNode(position) {
-        let node = new Node(position, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-        if (!this.nodes.get(position.x)) {
-            this.nodes.set(position.x, new Map());
-        }
-        this.nodes.get(position.x)?.set(position.y, node);
-        this.openMinBinaryHeap.add(node.pathLength, node);
-        return node;
-    }
-    isWalkable(position) {
-        return this.grid[position.y][position.x];
-    }
-    isPositionInsideGrid(position) {
-        return position.x >= 0 && position.x < this.width && position.y >= 0 && position.y < this.height;
+  constructor(grid, startingPosition) {
+    this.grid = grid;
+    this.startingPosition = startingPosition;
+    this.nodes = new Map();
+    this.openMinBinaryHeap = new binary_heap_1.BinaryHeap('min');
+    this.closedSet = [];
+    this.width = grid[0].length;
+    this.height = grid.length;
+    const startingNode = new Node(this.startingPosition, 0, Number.MAX_SAFE_INTEGER);
+    this.openMinBinaryHeap.add(startingNode.pathLength, startingNode);
+  }
+  get hasOpenNodes() {
+    return this.openMinBinaryHeap.size > 0;
+  }
+  getNeighbors(node) {
+    return DIRECTIONS.map(direction => ({
+      x: node.position.x + direction.x,
+      y: node.position.y + direction.y
+    }))
+      .filter(neighborPosition => this.isPositionInsideGrid(neighborPosition) && this.isWalkable(neighborPosition))
+      .map(
+        neighborPosition => this.nodes.get(neighborPosition.x)?.get(neighborPosition.y) || this.createNewNode(neighborPosition)
+      );
+  }
+  popLowestPathCostNode() {
+    const lowestPathNode = this.openMinBinaryHeap.pop();
+    this.openMinBinaryHeap.delete(lowestPathNode);
+    lowestPathNode.closed = true;
+    this.closedSet.push(lowestPathNode);
+    return lowestPathNode;
+  }
+  getBestClosedNode() {
+    return this.closedSet.reduce((prev, current) => (prev.distanceToEnd < current.distanceToEnd ? prev : current));
+  }
+  changeNodeCost(node, distanceFromStart, targetPosition, newParent) {
+    this.openMinBinaryHeap.delete(node);
+    node.distanceFromStart = distanceFromStart;
+    node.distanceToEnd = node.getDistance(targetPosition);
+    node.parent = newParent;
+    this.openMinBinaryHeap.add(node.pathLength, node);
+  }
+  createNewNode(position) {
+    const node = new Node(position, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    if (!this.nodes.get(position.x)) {
+      this.nodes.set(position.x, new Map());
     }
+    this.nodes.get(position.x)?.set(position.y, node);
+    this.openMinBinaryHeap.add(node.pathLength, node);
+    return node;
+  }
+  isWalkable(position) {
+    return this.grid[position.y][position.x];
+  }
+  isPositionInsideGrid(position) {
+    return position.x >= 0 && position.x < this.width && position.y >= 0 && position.y < this.height;
+  }
 }
 class PathFinder {
-    /**
-     * Time Complexity: O(grid.height * grid.width)
-     * Space Complexity: O(grid.height * grid.width)
-     */
-    static findPath(gridValues, startingPosition, targetPosition) {
-        let grid = new Grid(gridValues, startingPosition);
-        while (grid.hasOpenNodes) {
-            let currentNode = grid.popLowestPathCostNode();
-            if (currentNode.isEqual(targetPosition)) {
-                return currentNode.createSolutionPath(true);
-            }
-            let neighbors = grid.getNeighbors(currentNode);
-            for (let neighbor of neighbors) {
-                if (!neighbor.closed) {
-                    let distanceFromStart = currentNode.distanceFromStart + currentNode.getDistance(neighbor.position);
-                    if (distanceFromStart < neighbor.distanceFromStart) {
-                        grid.changeNodeCost(neighbor, distanceFromStart, targetPosition, currentNode);
-                    }
-                }
-            }
+  /**
+   * Time Complexity: O(grid.height * grid.width)
+   * Space Complexity: O(grid.height * grid.width)
+   */
+  static findPath(gridValues, startingPosition, targetPosition) {
+    const grid = new Grid(gridValues, startingPosition);
+    while (grid.hasOpenNodes) {
+      const currentNode = grid.popLowestPathCostNode();
+      if (currentNode.isEqual(targetPosition)) {
+        return currentNode.createSolutionPath(true);
+      }
+      const neighbors = grid.getNeighbors(currentNode);
+      for (const neighbor of neighbors) {
+        if (!neighbor.closed) {
+          const distanceFromStart = currentNode.distanceFromStart + currentNode.getDistance(neighbor.position);
+          if (distanceFromStart < neighbor.distanceFromStart) {
+            grid.changeNodeCost(neighbor, distanceFromStart, targetPosition, currentNode);
+          }
         }
-        return grid.getBestClosedNode().createSolutionPath(false);
+      }
     }
+    return grid.getBestClosedNode().createSolutionPath(false);
+  }
 }
 exports.PathFinder = PathFinder;
-//# sourceMappingURL=path-finder.js.map
+//# sourceMappingURL=path-finder.js.map

package/dist/utilities/libraries/path-finder/path-finder.spec.js

@@ -1,116 +1,141 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_finder_1 = require("./path-finder");
+Object.defineProperty(exports, '__esModule', { value: true });
+const path_finder_1 = require('./path-finder');
 describe('PATH_FINDER', () => {
-    test('basic 1', () => {
-        let result = path_finder_1.PathFinder.findPath([[true]], { x: 0, y: 0 }, { x: 0, y: 0 });
-        expect(result).toEqual({ directPathAvailable: true, path: [{ x: 0, y: 0 }] });
+  test('basic 1', () => {
+    const result = path_finder_1.PathFinder.findPath([[true]], { x: 0, y: 0 }, { x: 0, y: 0 });
+    expect(result).toEqual({
+      directPathAvailable: true,
+      path: [{ x: 0, y: 0 }]
     });
-    test('basic 2', () => {
-        let result = path_finder_1.PathFinder.findPath([[false]], { x: 0, y: 0 }, { x: 0, y: 0 });
-        expect(result).toEqual({ directPathAvailable: true, path: [{ x: 0, y: 0 }] });
+  });
+  test('basic 2', () => {
+    const result = path_finder_1.PathFinder.findPath([[false]], { x: 0, y: 0 }, { x: 0, y: 0 });
+    expect(result).toEqual({
+      directPathAvailable: true,
+      path: [{ x: 0, y: 0 }]
     });
-    test('should give the shortest path 1', () => {
-        let result = path_finder_1.PathFinder.findPath([
-            [true, true, true, true],
-            [true, false, false, true],
-            [true, false, false, true],
-            [true, false, false, true]
-        ], { x: 0, y: 0 }, { x: 3, y: 3 });
-        expect(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 1, y: 0 },
-                { x: 2, y: 0 },
-                { x: 3, y: 1 },
-                { x: 3, y: 2 },
-                { x: 3, y: 3 }
-            ]
-        });
+  });
+  test('should give the shortest path 1', () => {
+    const result = path_finder_1.PathFinder.findPath(
+      [
+        [true, true, true, true],
+        [true, false, false, true],
+        [true, false, false, true],
+        [true, false, false, true]
+      ],
+      { x: 0, y: 0 },
+      { x: 3, y: 3 }
+    );
+    expect(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 1, y: 0 },
+        { x: 2, y: 0 },
+        { x: 3, y: 1 },
+        { x: 3, y: 2 },
+        { x: 3, y: 3 }
+      ]
     });
-    test('should give the shortest path 2', () => {
-        let result = path_finder_1.PathFinder.findPath([
-            [true, true, true, false],
-            [true, false, false, false],
-            [true, true, false, true],
-            [true, false, true, true]
-        ], { x: 0, y: 0 }, { x: 3, y: 3 });
-        expect(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 0, y: 1 },
-                { x: 1, y: 2 },
-                { x: 2, y: 3 },
-                { x: 3, y: 3 }
-            ]
-        });
+  });
+  test('should give the shortest path 2', () => {
+    const result = path_finder_1.PathFinder.findPath(
+      [
+        [true, true, true, false],
+        [true, false, false, false],
+        [true, true, false, true],
+        [true, false, true, true]
+      ],
+      { x: 0, y: 0 },
+      { x: 3, y: 3 }
+    );
+    expect(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 1, y: 2 },
+        { x: 2, y: 3 },
+        { x: 3, y: 3 }
+      ]
     });
-    test('should give the shortest path 3', () => {
-        let result = path_finder_1.PathFinder.findPath([
-            [true, false, false, true, false],
-            [true, false, true, false, true],
-            [true, false, true, false, true],
-            [false, true, false, false, true]
-        ], { x: 0, y: 0 }, { x: 4, y: 3 });
-        expect(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 0, y: 0 },
-                { x: 0, y: 1 },
-                { x: 0, y: 2 },
-                { x: 1, y: 3 },
-                { x: 2, y: 2 },
-                { x: 2, y: 1 },
-                { x: 3, y: 0 },
-                { x: 4, y: 1 },
-                { x: 4, y: 2 },
-                { x: 4, y: 3 }
-            ]
-        });
+  });
+  test('should give the shortest path 3', () => {
+    const result = path_finder_1.PathFinder.findPath(
+      [
+        [true, false, false, true, false],
+        [true, false, true, false, true],
+        [true, false, true, false, true],
+        [false, true, false, false, true]
+      ],
+      { x: 0, y: 0 },
+      { x: 4, y: 3 }
+    );
+    expect(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 0, y: 2 },
+        { x: 1, y: 3 },
+        { x: 2, y: 2 },
+        { x: 2, y: 1 },
+        { x: 3, y: 0 },
+        { x: 4, y: 1 },
+        { x: 4, y: 2 },
+        { x: 4, y: 3 }
+      ]
     });
-    test('should give the shortest path backwards 3', () => {
-        let result = path_finder_1.PathFinder.findPath([
-            [true, false, false, true, false],
-            [true, false, true, false, true],
-            [true, false, true, false, true],
-            [false, true, false, false, true]
-        ], { x: 4, y: 3 }, { x: 0, y: 0 });
-        expect(result).toEqual({
-            directPathAvailable: true,
-            path: [
-                { x: 4, y: 3 },
-                { x: 4, y: 2 },
-                { x: 4, y: 1 },
-                { x: 3, y: 0 },
-                { x: 2, y: 1 },
-                { x: 2, y: 2 },
-                { x: 1, y: 3 },
-                { x: 0, y: 2 },
-                { x: 0, y: 1 },
-                { x: 0, y: 0 }
-            ]
-        });
+  });
+  test('should give the shortest path backwards 3', () => {
+    const result = path_finder_1.PathFinder.findPath(
+      [
+        [true, false, false, true, false],
+        [true, false, true, false, true],
+        [true, false, true, false, true],
+        [false, true, false, false, true]
+      ],
+      { x: 4, y: 3 },
+      { x: 0, y: 0 }
+    );
+    expect(result).toEqual({
+      directPathAvailable: true,
+      path: [
+        { x: 4, y: 3 },
+        { x: 4, y: 2 },
+        { x: 4, y: 1 },
+        { x: 3, y: 0 },
+        { x: 2, y: 1 },
+        { x: 2, y: 2 },
+        { x: 1, y: 3 },
+        { x: 0, y: 2 },
+        { x: 0, y: 1 },
+        { x: 0, y: 0 }
+      ]
     });
-    test('should give the shortest path to closest position', () => {
-        let result = path_finder_1.PathFinder.findPath([
-            [true, true, true, false],
-            [true, false, false, false],
-            [true, false, false, false],
-            [true, true, false, true]
-        ], { x: 0, y: 0 }, { x: 3, y: 3 });
-        expect(result).toEqual({
-            directPathAvailable: false,
-            path: [
-                { x: 0, y: 0 },
-                { x: 0, y: 1 },
-                { x: 0, y: 2 },
-                { x: 1, y: 3 }
-            ]
-        });
+  });
+  test('should give the shortest path to closest position', () => {
+    const result = path_finder_1.PathFinder.findPath(
+      [
+        [true, true, true, false],
+        [true, false, false, false],
+        [true, false, false, false],
+        [true, true, false, true]
+      ],
+      { x: 0, y: 0 },
+      { x: 3, y: 3 }
+    );
+    expect(result).toEqual({
+      directPathAvailable: false,
+      path: [
+        { x: 0, y: 0 },
+        { x: 0, y: 1 },
+        { x: 0, y: 2 },
+        { x: 1, y: 3 }
+      ]
     });
-    /*
+  });
+  /*
     test('stress test', () => {
       let size = 1600;
       let centerPos = { x: Math.floor(size / 2), y: Math.floor(size / 2) };
@@ -130,4 +155,4 @@ describe('PATH_FINDER', () => {
       console.log(end.getTime() - start.getTime());
     });*/
 });
-//# sourceMappingURL=path-finder.spec.js.map
+//# sourceMappingURL=path-finder.spec.js.map

package/dist/utilities/services/keyboard/keyboard.d.ts

@@ -1,7 +1,7 @@
 import { Action } from 'actions-lib';
 export declare class KeyboardService {
-    readonly keyPressed: Action<string>;
-    private listOfPressedKeys;
-    constructor();
-    isKeyDown(key: string): boolean;
+  readonly keyPressed: Action<string>;
+  private listOfPressedKeys;
+  constructor();
+  isKeyDown(key: string): boolean;
 }

package/dist/utilities/services/keyboard/keyboard.js

@@ -1,39 +1,47 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+var __decorate =
+  (this && this.__decorate) ||
+  ((decorators, target, key, desc) => {
+    var c = arguments.length,
+      r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
+      d;
+    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
+      r = Reflect.decorate(decorators, target, key, desc);
+    else
+      for (var i = decorators.length - 1; i >= 0; i--)
+        if ((d = decorators[i])) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  });
+var __metadata =
+  (this && this.__metadata) ||
+  ((k, v) => {
+    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') return Reflect.metadata(k, v);
+  });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.KeyboardService = void 0;
-const actions_lib_1 = require("actions-lib");
-const service_1 = require("../../../game-entities/service/service");
+const actions_lib_1 = require('actions-lib');
+const service_1 = require('../../../game-entities/service/service');
 let KeyboardService = class KeyboardService {
-    constructor() {
-        this.keyPressed = new actions_lib_1.Action();
-        this.listOfPressedKeys = new Set();
-        window.addEventListener('keydown', event => {
-            this.listOfPressedKeys.add(event.key);
-            !event.repeat && this.keyPressed.trigger(event.key);
-        });
-        window.addEventListener('keyup', event => {
-            this.listOfPressedKeys.delete(event.key);
-        });
-        window.addEventListener('blur', () => {
-            this.listOfPressedKeys.clear();
-        });
-    }
-    isKeyDown(key) {
-        return this.listOfPressedKeys.has(key);
-    }
+  constructor() {
+    this.keyPressed = new actions_lib_1.Action();
+    this.listOfPressedKeys = new Set();
+    window.addEventListener('keydown', event => {
+      this.listOfPressedKeys.add(event.key);
+      !event.repeat && this.keyPressed.trigger(event.key);
+    });
+    window.addEventListener('keyup', event => {
+      this.listOfPressedKeys.delete(event.key);
+    });
+    window.addEventListener('blur', () => {
+      this.listOfPressedKeys.clear();
+    });
+  }
+  isKeyDown(key) {
+    return this.listOfPressedKeys.has(key);
+  }
 };
 exports.KeyboardService = KeyboardService;
-exports.KeyboardService = KeyboardService = __decorate([
-    (0, service_1.ServiceDecorator)(),
-    __metadata("design:paramtypes", [])
-], KeyboardService);
-//# sourceMappingURL=keyboard.js.map
+exports.KeyboardService = KeyboardService = __decorate(
+  [(0, service_1.ServiceDecorator)(), __metadata('design:paramtypes', [])],
+  KeyboardService
+);
+//# sourceMappingURL=keyboard.js.map

package/dist/utilities/services/mouse/helpers/mouse-position.helper.d.ts

@@ -1,4 +1,4 @@
 import { Vector } from 'helpers-lib';
 export declare class MousePositionHelper {
-    static includeScaleInScreenPosition(screenPosition: Vector, gameInstanceScale: number, screenSizeCenter: Vector): Vector;
+  static includeScaleInScreenPosition(screenPosition: Vector, gameInstanceScale: number, screenSizeCenter: Vector): Vector;
 }

package/dist/utilities/services/mouse/helpers/mouse-position.helper.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.MousePositionHelper = void 0;
-const helpers_lib_1 = require("helpers-lib");
+const helpers_lib_1 = require('helpers-lib');
 class MousePositionHelper {
-    static includeScaleInScreenPosition(screenPosition, gameInstanceScale, screenSizeCenter) {
-        if (gameInstanceScale !== 1) {
-            let centerToScaledScreenPosition = helpers_lib_1.Vector.fromTo(screenSizeCenter, screenPosition).multiply(1 / gameInstanceScale);
-            return screenSizeCenter.add(centerToScaledScreenPosition);
-        }
-        else {
-            return screenPosition;
-        }
+  static includeScaleInScreenPosition(screenPosition, gameInstanceScale, screenSizeCenter) {
+    if (gameInstanceScale !== 1) {
+      const centerToScaledScreenPosition = helpers_lib_1.Vector.fromTo(screenSizeCenter, screenPosition).multiply(
+        1 / gameInstanceScale
+      );
+      return screenSizeCenter.add(centerToScaledScreenPosition);
+    } else {
+      return screenPosition;
     }
+  }
 }
 exports.MousePositionHelper = MousePositionHelper;
-//# sourceMappingURL=mouse-position.helper.js.map
+//# sourceMappingURL=mouse-position.helper.js.map