fast-astar 1.0.5 → 2.0.0

package/wasm.d.ts

@@ -0,0 +1,89 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class AstarGrid {
+    free(): void;
+    [Symbol.dispose](): void;
+    batchFindPaths(requests: Int32Array): Int32Array;
+    clearObstacles(): void;
+    findPath(start_x: number, start_y: number, end_x: number, end_y: number, optimal_result: boolean): Int32Array;
+    getHeight(): number;
+    getObstacleCount(): number;
+    getWidth(): number;
+    isWalkable(x: number, y: number): boolean;
+    constructor(width: number, height: number);
+    setObstacle(x: number, y: number, is_obstacle: boolean): void;
+    setObstaclesBatch(obstacles_data: Uint8Array): void;
+    setObstaclesFromCoords(coords: Int32Array): void;
+}
+
+export class AstarGridSparse {
+    free(): void;
+    [Symbol.dispose](): void;
+    clearObstacles(): void;
+    findPath(start_x: bigint, start_y: bigint, end_x: bigint, end_y: bigint, optimal_result: boolean): Int32Array;
+    getHeight(): bigint;
+    getObstacleCount(): number;
+    getWidth(): bigint;
+    constructor(width: bigint, height: bigint);
+    setObstacle(x: bigint, y: bigint, is_obstacle: boolean): void;
+    setObstaclesFromCoords(coords: Int32Array): void;
+}
+
+export function getVersion(): string;
+
+export function recommendedImpl(width: bigint, height: bigint): number;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_astargrid_free: (a: number, b: number) => void;
+    readonly __wbg_astargridsparse_free: (a: number, b: number) => void;
+    readonly astargrid_batchFindPaths: (a: number, b: number, c: number, d: number) => void;
+    readonly astargrid_clearObstacles: (a: number) => void;
+    readonly astargrid_findPath: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly astargrid_getHeight: (a: number) => number;
+    readonly astargrid_getObstacleCount: (a: number) => number;
+    readonly astargrid_getWidth: (a: number) => number;
+    readonly astargrid_isWalkable: (a: number, b: number, c: number) => number;
+    readonly astargrid_new: (a: number, b: number) => number;
+    readonly astargrid_setObstacle: (a: number, b: number, c: number, d: number) => void;
+    readonly astargrid_setObstaclesBatch: (a: number, b: number, c: number) => void;
+    readonly astargrid_setObstaclesFromCoords: (a: number, b: number, c: number) => void;
+    readonly astargridsparse_clearObstacles: (a: number) => void;
+    readonly astargridsparse_findPath: (a: number, b: number, c: bigint, d: bigint, e: bigint, f: bigint, g: number) => void;
+    readonly astargridsparse_getHeight: (a: number) => bigint;
+    readonly astargridsparse_getObstacleCount: (a: number) => number;
+    readonly astargridsparse_getWidth: (a: number) => bigint;
+    readonly astargridsparse_new: (a: bigint, b: bigint) => number;
+    readonly astargridsparse_setObstacle: (a: number, b: bigint, c: bigint, d: number) => void;
+    readonly astargridsparse_setObstaclesFromCoords: (a: number, b: number, c: number) => void;
+    readonly getVersion: (a: number) => void;
+    readonly recommendedImpl: (a: bigint, b: bigint) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/wasm.js

@@ -0,0 +1,388 @@
+/* @ts-self-types="./astar_wasm.d.ts" */
+export class AstarGrid {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AstarGridFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_astargrid_free(ptr, 0);
+    }
+    /**
+     * @param {Int32Array} requests
+     * @returns {Int32Array}
+     */
+    batchFindPaths(requests) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray32ToWasm0(requests, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.astargrid_batchFindPaths(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayI32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    clearObstacles() {
+        wasm.astargrid_clearObstacles(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} start_x
+     * @param {number} start_y
+     * @param {number} end_x
+     * @param {number} end_y
+     * @param {boolean} optimal_result
+     * @returns {Int32Array}
+     */
+    findPath(start_x, start_y, end_x, end_y, optimal_result) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.astargrid_findPath(retptr, this.__wbg_ptr, start_x, start_y, end_x, end_y, optimal_result);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayI32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    getHeight() {
+        const ret = wasm.astargrid_getHeight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    getObstacleCount() {
+        const ret = wasm.astargrid_getObstacleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    getWidth() {
+        const ret = wasm.astargrid_getWidth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean}
+     */
+    isWalkable(x, y) {
+        const ret = wasm.astargrid_isWalkable(this.__wbg_ptr, x, y);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height) {
+        const ret = wasm.astargrid_new(width, height);
+        this.__wbg_ptr = ret >>> 0;
+        AstarGridFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} is_obstacle
+     */
+    setObstacle(x, y, is_obstacle) {
+        wasm.astargrid_setObstacle(this.__wbg_ptr, x, y, is_obstacle);
+    }
+    /**
+     * @param {Uint8Array} obstacles_data
+     */
+    setObstaclesBatch(obstacles_data) {
+        const ptr0 = passArray8ToWasm0(obstacles_data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.astargrid_setObstaclesBatch(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {Int32Array} coords
+     */
+    setObstaclesFromCoords(coords) {
+        const ptr0 = passArray32ToWasm0(coords, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.astargrid_setObstaclesFromCoords(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) AstarGrid.prototype[Symbol.dispose] = AstarGrid.prototype.free;
+export class AstarGridSparse {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AstarGridSparseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_astargridsparse_free(ptr, 0);
+    }
+    clearObstacles() {
+        wasm.astargridsparse_clearObstacles(this.__wbg_ptr);
+    }
+    /**
+     * @param {bigint} start_x
+     * @param {bigint} start_y
+     * @param {bigint} end_x
+     * @param {bigint} end_y
+     * @param {boolean} optimal_result
+     * @returns {Int32Array}
+     */
+    findPath(start_x, start_y, end_x, end_y, optimal_result) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.astargridsparse_findPath(retptr, this.__wbg_ptr, start_x, start_y, end_x, end_y, optimal_result);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayI32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    getHeight() {
+        const ret = wasm.astargridsparse_getHeight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    getObstacleCount() {
+        const ret = wasm.astargridsparse_getObstacleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {bigint}
+     */
+    getWidth() {
+        const ret = wasm.astargridsparse_getWidth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {bigint} width
+     * @param {bigint} height
+     */
+    constructor(width, height) {
+        const ret = wasm.astargridsparse_new(width, height);
+        this.__wbg_ptr = ret >>> 0;
+        AstarGridSparseFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {bigint} x
+     * @param {bigint} y
+     * @param {boolean} is_obstacle
+     */
+    setObstacle(x, y, is_obstacle) {
+        wasm.astargridsparse_setObstacle(this.__wbg_ptr, x, y, is_obstacle);
+    }
+    /**
+     * @param {Int32Array} coords
+     */
+    setObstaclesFromCoords(coords) {
+        const ptr0 = passArray32ToWasm0(coords, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.astargridsparse_setObstaclesFromCoords(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) AstarGridSparse.prototype[Symbol.dispose] = AstarGridSparse.prototype.free;
+/**
+ * @returns {string}
+ */
+export function getVersion() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.getVersion(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+    }
+}
+/**
+ * @param {bigint} width
+ * @param {bigint} height
+ * @returns {number}
+ */
+export function recommendedImpl(width, height) {
+    const ret = wasm.recommendedImpl(width, height);
+    return ret;
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+    };
+    return {
+        __proto__: null,
+        "./astar_wasm_bg.js": import0,
+    };
+}
+const AstarGridFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_astargrid_free(ptr >>> 0, 1));
+const AstarGridSparseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_astargridsparse_free(ptr >>> 0, 1));
+function getArrayI32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+let cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+let WASM_VECTOR_LEN = 0;
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedInt32ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+                } else { throw e; }
+            }
+        }
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+    if (module_or_path === undefined) {
+        module_or_path = new URL('astar.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+    return __wbg_finalize_init(instance, module);
+}
+export { initSync, __wbg_init as default };

package/dist/Astar.js

@@ -1,2 +0,0 @@
-/*! Project:astar, Create:FWS 2019.10.29 15:21, Update:FWS 2019.10.30 10:16 */ 
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):"function"==typeof define&&(define.cmd||define.hjs)?define(function(require,exports,e){e.exports=t()}):e.Astar=t()}(this,function(){"use strict";var e=function(e){return e.split(",").map(Number)};return function(){function t(e){var t=this;t.grid=e,t.openList={},t.closeList={},t.current}return t.prototype.search=function(e,t,r){var n=this,i={rightAngle:!1,optimalResult:!0};r=n.searchOption=r||{};for(var o in i)r[o]===undefined&&(r[o]=i[o]);n.start=e,n.end=t,n.grid.get(e).value=0,n.grid.set(e,"type","start"),n.grid.get(t).value=0,n.grid.set(t,"type","end");var d,u;return n.openList[e]=null,n.grid.set(e,"type","open"),(u=function(e){if(n.grid.set(e,"type","highlight"),n.grid.get(e)===n.grid.get(n.end))d=n.getBackPath(e);else{for(var t=n.getAround(e),r=0,i=t.length;r<i;r++){var o=t[r],l=n.grid.get(o);if(null!==n.openList[o])n.openList[o]=null,l.parent=e,l.g=n.g(o,e),l.h=n.h(o,n.end),l.f=n.f(o),n.grid.set(o,"type","open");else{var s=l.g,g=n.g(o,e);g<s&&(l.parent=e,l.g=g,l.f=n.f(o),n.grid.set(o,"type","update"))}}delete n.openList[e],n.closeList[e]=null,n.grid.set(e,"type","close");var f=n.getOpenListMin();f&&u(f.key)}})(e),d},t.prototype.getBackPath=function(e){var t,r=this,n=[e];return(t=function(e){var i=r.grid.get(e).parent;i&&(n.unshift(i),t(i))})(e),n},t.prototype.getOpenListMin=function(){var t,r=this;for(var n in r.openList){var i=e(n),o=r.grid.get(i);(t===undefined||o.f<t.f)&&(t=r.grid.get(i))}return t},t.prototype.getOffsetGrid=function(e,t){return[e[0]+t[0],e[1]+t[1]]},t.prototype.getAround=function(e){var t=this,r=t.searchOption,n=[],i=t.grid,o={lt:[-1,-1],t:[0,-1],rt:[1,-1],r:[1,0],rb:[1,1],b:[0,1],lb:[-1,1],l:[-1,0]},d=function(e,r){var n=i.get(t.getOffsetGrid(e,r));return n!==undefined&&n.value>0};r.rightAngle?(delete o.lt,delete o.rt,delete o.rb,delete o.lb):(d(e,o.l)&&(delete o.lt,delete o.lb),d(e,o.r)&&(delete o.rt,delete o.rb),d(e,o.t)&&(delete o.lt,delete o.rt),d(e,o.b)&&(delete o.lb,delete o.rb));for(var u in o){var l=o[u],s=[e[0]+l[0],e[1]+l[1]],g=null===t.closeList[s];s[0]>-1&&s[0]<i.col&&s[1]>-1&&s[1]<i.row&&!g&&i.get(s).value<1&&n.push(s)}return n},t.prototype.f=function(e){var t=this,r=t.grid.get(e);return r.g+r.h},t.prototype.g=function(e,t){return this.searchOption.optimalResult?(t[0]===e[0]||t[1]===e[1]?10:14)+this.grid.get(t).g:0},t.prototype.h=function(e,t){return 10*(Math.abs(e[0]-t[0])+Math.abs(e[1]-t[1]))},t}()});

package/dist/Grid.js

@@ -1,2 +0,0 @@
-/*! Project:astar, Create:FWS 2019.10.29 15:21, Update:FWS 2019.10.30 10:16 */ 
-!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):"function"==typeof define&&(define.cmd||define.hjs)?define(function(require,exports,e){e.exports=n()}):e.Grid=n()}(this,function(){"use strict";var e=function(e,n){return~~(Math.random()*(n-e+1))+e},n=function(e,n){var t=this;t.x=e,t.y=n,t.g=0,t.h=0,t.f=0,t.value=0,t.key=[e,n]};return function(){function t(e){var n=this;n.col=e.col,n.row=e.row,n.grid=n.createGrid(e.col,e.row,e.render)}return t.prototype.obstacle=function(n,t){for(var r,o=this,i=~~(o.col*o.row*n/100),u=[],f={},c=0;c<i;c++)(r=function(){u[0]=e(0,o.col-1),u[1]=e(0,o.row-1);var n=o.get(u);0===n.value?(n.value=t,f[[u[0],u[1]]]=null):r()})();return f},t.prototype.get=function(e){var n=this.grid[e[1]];return n?n[e[0]]:undefined},t.prototype.set=function(e,n,t){var r=this.get(e);r[n]=t,"function"==typeof r.render&&r.render({key:n,val:t})},t.prototype.createGrid=function(e,t,r){for(var o=[],i=0;i<t;i++)!function(t){var i=function(){for(var o=[],i=0;i<e;i++){var u=new n(i,t);"function"==typeof r&&(u.render=r),o[i]=u}return o}();o.push(i)}(i);return o},t.prototype.getData=function(){for(var e=this,n=e.grid,t=[],r=0,o=n.length;r<o;r++)!function(e,r){var o=n[e];t.push(function(){for(var e=[],n=0,t=o.length;n<t;n++)e.push(o[n].value);return e}())}(r);return t},t}()});

package/dist/index.js

@@ -1,3 +0,0 @@
-const Grid = require('./Grid'),
-    Astar = require('./Astar');
-module.exports = {Grid,Astar};