@adobe/data 0.2.1 → 0.2.3

package/dist/ecs/core-ecs/core-ecs-types.d.ts

@@ -0,0 +1,141 @@
+import { Data, FromSchema, Schema } from "../../core/index.js";
+import { DeepReadonly, Simplify } from "../../types/types.js";
+import { NativeArray } from "../../cache/managed-array.js";
+/**
+ * An Entity represents a single object within the ECS.
+ * It is a unique positive integer identifier that can be used to access the components of the entity.
+ */
+export type Entity = number;
+/**
+ * Represents all of an entities values for the given ECS components.
+ * This will always contain an id property which is the entity id.
+ * All other components are optional.
+ */
+export type EntityValues<C> = {
+    id: number;
+} & {
+    [K in keyof C]?: C[K] | undefined;
+};
+/**
+ * Represents the values you can use when creating an entity.
+ * You cannot provide an id as this is always generated by the ECS.
+ */
+export type EntityCreateValues<A> = Omit<A, "id">;
+/**
+ * Represents the values you can use when updating an entity.
+ * Providing a value of undefined for a component will delete it.
+ */
+export type EntityUpdateValues<C> = Omit<{
+    [K in keyof C]?: C[K] | undefined;
+}, "id">;
+/**
+ * The JSON data type that is used to serialize and deserialize ECS data.
+ */
+export type ECSJSON = {
+    ecs: true;
+    version: number;
+    components: Record<string, Schema>;
+    entities: readonly number[];
+    tables: {
+        rows: number;
+        columns: Record<string, Data>;
+    }[];
+};
+export type CoreComponents = {
+    id: number;
+};
+export type CoreResources = {
+    [K: string]: Data;
+};
+export interface CoreECS<C extends CoreComponents = CoreComponents, R extends CoreResources = {}> extends CoreECSRead<C, R>, CoreECSWrite<C, R> {
+    /**
+     * Creates new components within this ecs and returns the same ecs with the new expanded type information.
+     */
+    withComponents<S extends {
+        readonly [K: string]: DeepReadonly<Schema>;
+    }, T = {
+        -readonly [K in keyof S]: FromSchema<S[K]>;
+    }>(components: S): CoreECS<Simplify<C & T>, R>;
+    withResources<T extends {
+        readonly [K: string]: Data;
+    }>(resources: T): CoreECS<C, Simplify<R & T>>;
+}
+export interface CoreECSRead<C extends CoreComponents = CoreComponents, R extends CoreResources = {}> {
+    components: {
+        readonly [K in keyof C]: Schema;
+    };
+    resources: R;
+    /**
+     * Returns the component value for the given entity.
+     * @param component the component to read.
+     * @param id if not provided, uses the component own entity id as with resources.
+     */
+    getComponentValue<Name extends keyof C>(id: Entity, component: Name): C[Name] | undefined;
+    getArchetype<Components extends (keyof C)[]>(...components: Components): CoreArchetype<{
+        [K in Components[number]]: C[K];
+    }>;
+    getEntityValues(id: Entity): EntityValues<C> | undefined;
+    getEntityArchetype(id: Entity): CoreArchetype;
+    countEntities<T extends CoreComponents>(archetype: CoreArchetype<T>): number;
+    selectEntities<T extends CoreComponents>(archetype: CoreArchetype<T>): Entity[];
+    toJSON(): ECSJSON;
+}
+export interface CoreECSWrite<C extends CoreComponents = CoreComponents, R extends CoreResources = {}> {
+    createEntity(): Entity;
+    createEntity<T extends CoreComponents>(archetype: CoreArchetype<T>, values: Omit<T, "id">): Entity;
+    createBatch<T extends CoreComponents>(archetype: CoreArchetype<T>, count: number): Table<T>;
+    /**
+     * Sets the value of a component for the given entity.
+     * @param component the component to write.
+     * @param value the value of the component or undefined to delete the component.
+     * @param id if not provided, uses the components own entity id as with resources.
+     */
+    setComponentValue<Name extends keyof C>(id: Entity, component: Name, value: C[Name] | undefined): void;
+    /**
+     * Gets the tables for the given archetype in read or write mode.
+     * @param exact if true, only returns the single table that exactly matches the archetype.
+     */
+    getTables<T extends CoreComponents>(archetype: CoreArchetype<T>, options: {
+        mode: "read" | "write";
+        exact?: boolean;
+    }): Table<C>[];
+    updateEntity(id: Entity, values: EntityUpdateValues<C>): void;
+    deleteEntity(id: Entity): void;
+}
+export interface CoreArchetype<C = {
+    [K: string]: unknown;
+}> {
+    readonly components: (keyof C)[];
+}
+/**
+ * A Table represents a collection of entities with the same exact archetype.
+ */
+export interface Table<C = {
+    [K: string]: unknown;
+}> {
+    readonly rows: number;
+    readonly columns: {
+        [K in keyof C]: Column<C[K]>;
+    };
+}
+/**
+ * A column represents an array of values for a single component.
+ * Each row in the column corresponds to a single entity within the containing Table.
+ * The ECS stores data as a structure of arrays.
+ */
+export interface Column<T> {
+    get(row: number): T;
+    set(row: number, value: T): void;
+    /**
+     * Allows unsafe direct access to the underlying native array if present.
+     * Not present for constant columns.
+     * For numeric tuples, the array will be of the form [a0, a1, a2, b0, b1, b2, ...]
+     */
+    native?: NativeArray<T extends number[] ? number : T>;
+    /**
+     * Is every value in this column the same?
+     */
+    constant: boolean;
+    toJSON(length: number): Data;
+    fromJSON(data: Data, length: number): void;
+}

package/dist/ecs/core-ecs/core-ecs-types.js

@@ -0,0 +1,23 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export {};
+//# sourceMappingURL=core-ecs-types.js.map

package/dist/ecs/core-ecs/core-ecs-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-ecs-types.js","sourceRoot":"","sources":["../../../src/ecs/core-ecs/core-ecs-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;WAoBW"}

package/dist/ecs/core-ecs/core-ecs.d.ts

@@ -0,0 +1,7 @@
+import { MemoryAllocator } from "../../cache/memory-allocator.js";
+import { CoreECS, CoreComponents, ECSJSON, CoreResources } from "./core-ecs-types.js";
+export declare const DELETE: unknown;
+export declare function createCoreECS<C extends CoreComponents, R extends CoreResources>(options?: {
+    data?: ECSJSON;
+    allocator?: MemoryAllocator;
+}): CoreECS<CoreComponents, {}>;

package/dist/ecs/core-ecs/core-ecs.js

@@ -0,0 +1,492 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { equals, normalize, } from "../../core/index.js";
+import { createManagedArray, } from "../../cache/managed-array.js";
+import { createSimpleMemoryAllocator, } from "../../cache/memory-allocator.js";
+import { Uint32Schema } from "../../core/schema/schemas.js";
+//  This is a sentinel value used to indicate a component should be deleted.
+export const DELETE = "_@_DELETE_@_";
+export function createCoreECS(options = {}) {
+    const ELEMENTS_PER_RECORD = 2;
+    const DELETED_ARCHETYPE = 0xff;
+    const componentSchemas = {
+        id: Uint32Schema,
+    };
+    const getSchema = (name) => {
+        const schema = componentSchemas[name];
+        if (!schema) {
+            throw new Error(`Component "${String(name)}" not found`);
+        }
+        return schema;
+    };
+    const resources = {};
+    let recordCount = 0;
+    let recordCapacity = 1024;
+    let firstDeletedId = 0;
+    let records = new Uint32Array(recordCapacity * ELEMENTS_PER_RECORD);
+    const { allocator = createSimpleMemoryAllocator() } = options;
+    //  What if we remove internal components?
+    //  id, name, component, schema?
+    //  We DO need id as a component since it gets it's own column.
+    //  But do we need to track components internally?
+    //  [x] This is safely derived as needed.
+    const archetypeLookup = {};
+    //  [ ] the order of these is relevant for serialization currently.
+    const archetables = [];
+    //  [x] This is created as archetypes are requested.
+    const componentsToArchetypes = new Map();
+    /**
+     * Returns the component with the least number of archetypes containing it.
+     */
+    const getMostExclusiveComponent = (components) => {
+        if (components.length === 0) {
+            throw new Error("Cannot call with zero components");
+        }
+        let mostExclusive = components[0];
+        let size = Number.POSITIVE_INFINITY;
+        for (const component of components) {
+            const archetypes = getComponentsToArchetypes(component);
+            if (archetypes.size < size) {
+                size = archetypes.size;
+                mostExclusive = component;
+            }
+        }
+        return mostExclusive;
+    };
+    const getAdjacentArchetype = (archetable, component, addOrRemove) => {
+        let newTable = archetable[addOrRemove].get(component);
+        if (!newTable) {
+            const add = addOrRemove === "addComponent";
+            const newComponents = (add
+                ? [...archetable.components, component].sort()
+                : archetable.components.filter((c) => c !== component));
+            newTable = getArchetype(...newComponents);
+            //  add the edge lookup to the new table
+            archetable[addOrRemove].set(component, newTable);
+            newTable[addOrRemove === "addComponent" ? "removeComponent" : "addComponent"].set(component, archetable);
+        }
+        return newTable;
+    };
+    const getComponentValue = (id, component) => {
+        const index = id * ELEMENTS_PER_RECORD;
+        const archetable = archetables[records[index + 0]];
+        const row = records[index + 1];
+        const array = archetable.columns[component];
+        if (array === undefined) {
+            return undefined;
+        }
+        return array.get(row);
+    };
+    const setComponentValue = (id, component, value) => {
+        if (value === undefined) {
+            value = DELETE;
+        }
+        const index = id * ELEMENTS_PER_RECORD;
+        const archetable = archetables[records[index + 0]];
+        const currentRow = records[index + 1];
+        const array = archetable.columns[component];
+        if (value !== DELETE) {
+            if (array === undefined) {
+                //  add component
+                const newTable = getAdjacentArchetype(archetable, component, "addComponent");
+                const newRow = newTable.createRow();
+                //  manually move values over
+                for (const name of archetable.components) {
+                    const targetColumn = archetable.columns[name];
+                    if (targetColumn !== undefined) {
+                        newTable.columns[name].set(newRow, targetColumn.get(currentRow));
+                    }
+                }
+                //  set the new component value
+                newTable.columns[component].set(newRow, value);
+                archetable.deleteRow(currentRow);
+                records[index + 0] = newTable.id;
+                records[index + 1] = newRow;
+            }
+            else {
+                //  updating value
+                array.set(currentRow, value);
+            }
+        }
+        else if (array !== undefined) {
+            //  remove component
+            const newTable = getAdjacentArchetype(archetable, component, "removeComponent");
+            const newRow = newTable.createRow();
+            //  manually move values over, except for the removed one
+            for (const name of archetable.components) {
+                if (name !== component) {
+                    newTable.columns[name].set(newRow, archetable.columns[name].get(currentRow));
+                }
+            }
+            archetable.deleteRow(currentRow);
+            records[index + 0] = newTable.id;
+            records[index + 1] = newRow;
+        }
+    };
+    const getArchetype = (...components) => {
+        components.sort();
+        const ids = new Set(components);
+        if (!ids.has("id")) {
+            ids.add("id");
+            components.unshift("id");
+        }
+        const key = components.join(",");
+        let archetype = archetypeLookup[key];
+        if (!archetype) {
+            const columns = Object.fromEntries(components.map((name) => [
+                name,
+                createManagedArray(getSchema(name), allocator),
+            ]));
+            const id = archetables.length;
+            archetype =
+                archetables[id] =
+                    archetypeLookup[key] =
+                        {
+                            components,
+                            id,
+                            rows: 0,
+                            columns,
+                            addComponent: new Map(),
+                            removeComponent: new Map(),
+                            readRow: (row) => {
+                                const values = {};
+                                for (const name of components) {
+                                    values[name] = columns[name].get(row);
+                                }
+                                return values;
+                            },
+                            createRow: (values) => {
+                                const newRow = archetype.rows++;
+                                for (const name of components) {
+                                    const column = columns[name];
+                                    column.ensureCapacity(archetype.rows);
+                                    if (values) {
+                                        const value = values[name];
+                                        if (value === undefined) {
+                                            throw new Error(`Missing value for column "${String(name)}"`);
+                                        }
+                                        column.set(newRow, value);
+                                    }
+                                }
+                                return newRow;
+                            },
+                            deleteRow: (row) => {
+                                archetype.rows--;
+                                // the main ecs records row pointer is updated to the new row
+                                if (archetype.rows > 0) {
+                                    const movedRowId = columns.id.native[archetype.rows];
+                                    const movedRowIndex = movedRowId * ELEMENTS_PER_RECORD;
+                                    records[movedRowIndex + 1] = row;
+                                }
+                                //  then we remove each columns row, moving the last to replace it.
+                                for (const name of components) {
+                                    const column = columns[name];
+                                    if (column !== undefined) {
+                                        if (archetype.rows > 0) {
+                                            // the last row (at size) is moved to replace the deleted row
+                                            column.move(archetype.rows, row);
+                                        }
+                                    }
+                                }
+                            },
+                        };
+            for (const name of components) {
+                getComponentsToArchetypes(name).add(archetype);
+            }
+        }
+        return archetype;
+    };
+    const getEntityArchetype = (id) => {
+        return archetables[records[id * ELEMENTS_PER_RECORD]];
+    };
+    const getComponentsToArchetypes = (name) => {
+        let set = componentsToArchetypes.get(name);
+        if (!set) {
+            componentsToArchetypes.set(name, (set = new Set()));
+        }
+        return set;
+    };
+    const withComponents = (components) => {
+        Object.entries(components).forEach(([name, newSchema]) => {
+            const oldSchema = componentSchemas[name];
+            //  it's OK for a component to be defined more than once
+            //  so long as the schema is the same.
+            if (oldSchema && !equals(normalize(oldSchema), normalize(newSchema))) {
+                console.warn(`Component "${name}" schema changed from ${JSON.stringify(oldSchema)} to ${JSON.stringify(newSchema)}`);
+            }
+            componentSchemas[name] = newSchema;
+        });
+        return ecs;
+    };
+    const withResources = (newResources) => {
+        Object.entries(newResources).forEach(([name, value]) => {
+            //  register the resource as a component.
+            withComponents({ [name]: {} });
+            const archetype = getArchetype("id", name);
+            //  resource row *may* already exist if loaded from disk.
+            const entityId = archetype.rows
+                ? archetype.columns.id.get(archetype.rows)
+                : createEntity(archetype, { [name]: value });
+            const column = archetype.columns[name];
+            Object.defineProperty(resources, name, {
+                get: () => column.get(0),
+                set: (newValue) => {
+                    updateEntity(entityId, { [name]: newValue });
+                },
+            });
+        });
+        return ecs;
+    };
+    function getTables(archetype, options) {
+        if (!archetype) {
+            return archetables.filter((a) => a.rows > 0);
+        }
+        if (options?.exact) {
+            return [archetype];
+        }
+        const components = archetype.components;
+        const tables = [];
+        const baseSet = getComponentsToArchetypes(getMostExclusiveComponent(components));
+        for (const archetable of baseSet) {
+            if (archetable.rows === 0) {
+                continue;
+            }
+            let hasAll = true;
+            for (const component of components) {
+                if (!archetable.columns[component]) {
+                    hasAll = false;
+                    break;
+                }
+            }
+            if (hasAll) {
+                tables.push(archetable);
+            }
+        }
+        return tables;
+    }
+    const countEntities = (archetype) => {
+        let count = 0;
+        for (const table of getTables(archetype, { mode: "read" })) {
+            count += table.rows;
+        }
+        return count;
+    };
+    const selectEntities = (archetype) => {
+        const tables = getTables(archetype, { mode: "read" });
+        const entities = [];
+        let offset = 0;
+        for (const table of tables) {
+            // this native array will probably be longer than the actual size.
+            const size = table.rows;
+            const nativeArray = table.columns.id.native;
+            // copy from 0 .. size to entities
+            for (let i = 0; i < size; i++) {
+                entities[offset++] = nativeArray[i];
+            }
+        }
+        return entities;
+    };
+    const getEntityValues = (id) => {
+        const index = id * ELEMENTS_PER_RECORD;
+        const archetypeId = records[index + 0];
+        if (archetypeId === undefined || archetypeId === DELETED_ARCHETYPE) {
+            return undefined;
+        }
+        const archetable = archetables[records[index + 0]];
+        const row = records[index + 1];
+        const values = {};
+        for (const name of archetable.components) {
+            values[name] = archetable.columns[name].get(row);
+        }
+        return values;
+    };
+    const updateEntity = (id, values) => {
+        for (const name in values) {
+            if (name === "id") {
+                throw new Error("Cannot update id");
+            }
+            let value = values[name];
+            if (value === undefined) {
+                value = DELETE;
+            }
+            setComponentValue(id, name, value);
+        }
+    };
+    function ensureRecordCapacity(capacity) {
+        if (recordCapacity < capacity) {
+            recordCapacity = Math.max(capacity, recordCapacity * 2);
+            const newRecords = new Uint32Array(recordCapacity * ELEMENTS_PER_RECORD);
+            newRecords.set(records);
+            records = newRecords;
+        }
+    }
+    const createEntity = (_archetype, values) => {
+        const archetype = _archetype ?? emptyArchetype;
+        let id;
+        if (firstDeletedId > 0 && recordCount > 0) {
+            id = firstDeletedId;
+            const index = id * ELEMENTS_PER_RECORD;
+            //  point to the next deleted id
+            firstDeletedId = records[index + 1];
+        }
+        else {
+            //  create new entity record
+            ensureRecordCapacity(recordCount + 1);
+            id = recordCount++;
+        }
+        //  now put it directly into the archetype.
+        values = (values ? { ...values, id } : { id });
+        const row = archetype.createRow(values);
+        //  now add the records entry
+        const index = id * ELEMENTS_PER_RECORD;
+        records[index + 0] = archetype.id;
+        records[index + 1] = row;
+        return id;
+    };
+    const createBatch = (archetype, count) => {
+        const table = getTables(archetype, { mode: "write", exact: true })[0];
+        ensureRecordCapacity(recordCount + count);
+        for (const name in table.columns) {
+            const column = table.columns[name];
+            column.ensureCapacity(table.rows + count);
+        }
+        const ids = table.columns.id.native;
+        //  we are only going to rapidly create main record entries *and* the archetype id values.
+        let created = 0;
+        //  first recycle any deleted ids
+        while (created < count && firstDeletedId > 0 && recordCount > 0) {
+            const id = firstDeletedId;
+            const index = id * ELEMENTS_PER_RECORD;
+            //  point to the next deleted id
+            firstDeletedId = records[index + 1];
+            const row = table.rows + created++;
+            records[index + 0] = table.id;
+            records[index + 1] = row;
+            ids[row] = id;
+        }
+        recordCount += created;
+        //  then quickly create the rest
+        for (; created < count; created++) {
+            const id = recordCount++;
+            const row = table.rows + created;
+            records[id * ELEMENTS_PER_RECORD + 0] = table.id;
+            records[id * ELEMENTS_PER_RECORD + 1] = row;
+            ids[row] = id;
+        }
+        table.rows += count;
+        return table;
+    };
+    const deleteEntity = (id) => {
+        const index = id * ELEMENTS_PER_RECORD;
+        const archetype = archetables[records[index + 0]];
+        const row = records[index + 1];
+        archetype.deleteRow(row);
+        const nextDeletedId = firstDeletedId;
+        firstDeletedId = id;
+        records[index + 0] = DELETED_ARCHETYPE;
+        records[index + 1] = nextDeletedId;
+    };
+    //  this first archetype in the table must be the empty entity archetype which contains only the id.
+    const emptyArchetype = getArchetype("id");
+    //  1 = initial
+    //  2 = simplified format
+    //  3 = Numbers default to Float64Array instead of Float32Array
+    //  4 = bug fix for createRow not ensuring capacity
+    const SERIALIZATION_VERSION = 4;
+    const toJSON = () => {
+        return {
+            ecs: true,
+            version: SERIALIZATION_VERSION,
+            components: componentSchemas,
+            entities: [...records.slice(0, recordCount * 2)],
+            tables: archetables.map((table, index) => {
+                if (index !== table.id) {
+                    throw new Error(`Table id mismatch: ${index} !== ${table.id}`);
+                }
+                const { rows, columns } = table;
+                return {
+                    rows,
+                    columns: Object.fromEntries(Object.entries(columns).map(([name, column]) => {
+                        const value = column.toJSON(rows, name !== "id");
+                        return [name, value];
+                    })),
+                };
+            }),
+        };
+    };
+    const fromJSON = (json) => {
+        const { ecs, version, entities, tables } = json;
+        if (!ecs) {
+            throw new Error("Not an ECS");
+        }
+        if (version !== SERIALIZATION_VERSION) {
+            return false;
+        }
+        recordCount = entities.length / 2;
+        ensureRecordCapacity(recordCount);
+        records.set(entities);
+        Object.assign(componentSchemas, json.components);
+        for (let i = 0; i < tables.length; i++) {
+            const persistedTable = tables[i];
+            const { rows, columns } = persistedTable;
+            const components = Object.keys(columns);
+            const archetype = getArchetype(...components);
+            const [archetable] = getTables(archetype, {
+                mode: "write",
+                exact: true,
+            });
+            if (archetable.id !== i) {
+                throw new Error("Expected archetable to have the same id as the persisted table index");
+            }
+            archetable.rows = rows;
+            for (const [name, columnData] of Object.entries(columns)) {
+                const column = archetable.columns[name];
+                column.fromJSON(columnData, rows);
+            }
+        }
+        return true;
+    };
+    const ecs = {
+        components: componentSchemas,
+        resources,
+        getComponentValue,
+        setComponentValue,
+        countEntities,
+        selectEntities,
+        getTables,
+        getArchetype: getArchetype,
+        getEntityArchetype,
+        withComponents,
+        withResources,
+        getEntityValues,
+        createBatch,
+        createEntity,
+        updateEntity,
+        deleteEntity,
+        toJSON,
+    };
+    if (options.data) {
+        fromJSON(options.data);
+    }
+    return ecs;
+}
+//# sourceMappingURL=core-ecs.js.map