@latticexyz/world 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2 → 2.2.18-c2ad22c7feb566e1731ff16e8be291746bdffb3e

package/dist/internal.cjs

@@ -1,656 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ts/exports/internal.ts
-var internal_exports = {};
-__export(internal_exports, {
-  CODEGEN_DEFAULTS: () => CODEGEN_DEFAULTS,
-  CONFIG_DEFAULTS: () => CONFIG_DEFAULTS,
-  DEPLOY_DEFAULTS: () => DEPLOY_DEFAULTS,
-  MODULE_DEFAULTS: () => MODULE_DEFAULTS,
-  SYSTEM_DEFAULTS: () => SYSTEM_DEFAULTS,
-  SYSTEM_DEPLOY_DEFAULTS: () => SYSTEM_DEPLOY_DEFAULTS,
-  callFrom: () => callFrom,
-  defineNamespaces: () => defineNamespaces,
-  defineSystem: () => defineSystem,
-  defineWorld: () => defineWorld,
-  encodeSystemCall: () => encodeSystemCall,
-  encodeSystemCallFrom: () => encodeSystemCallFrom,
-  encodeSystemCalls: () => encodeSystemCalls,
-  encodeSystemCallsFrom: () => encodeSystemCallsFrom,
-  isDynamicResolution: () => isDynamicResolution,
-  isValueWithType: () => isValueWithType,
-  resolveCodegen: () => resolveCodegen,
-  resolveDeploy: () => resolveDeploy,
-  resolveNamespace: () => resolveNamespace,
-  resolveNamespaces: () => resolveNamespaces,
-  resolveSystem: () => resolveSystem,
-  resolveSystems: () => resolveSystems,
-  resolveTableId: () => resolveTableId,
-  resolveWithContext: () => resolveWithContext,
-  resolveWorld: () => resolveWorld,
-  validateNamespace: () => validateNamespace,
-  validateNamespaces: () => validateNamespaces,
-  validateSystem: () => validateSystem,
-  validateSystems: () => validateSystems,
-  validateWorld: () => validateWorld
-});
-module.exports = __toCommonJS(internal_exports);
-
-// ts/encodeSystemCall.ts
-var import_viem = require("viem");
-
-// ts/normalizeSystemFunctionName.ts
-var import_common = require("@latticexyz/common");
-function internal_normalizeSystemFunctionName(systemId, functionName) {
-  const resource = (0, import_common.hexToResource)(systemId);
-  const worldFunctionPrefix = resource.namespace !== "" ? `${resource.namespace}__` : null;
-  if (worldFunctionPrefix != null && functionName.startsWith(worldFunctionPrefix)) {
-    console.warn(
-      // eslint-disable-next-line max-len
-      `Detected world function name "${functionName}" used in call to system "${(0, import_common.resourceToLabel)(resource)}".
-
-It's recommended to use a system ABI and system function name with these methods instead.`
-    );
-    return functionName.slice(worldFunctionPrefix.length);
-  }
-  return functionName;
-}
-
-// ts/encodeSystemCall.ts
-function encodeSystemCall({
-  abi,
-  systemId,
-  functionName,
-  args
-}) {
-  return [
-    systemId,
-    (0, import_viem.encodeFunctionData)({
-      abi,
-      functionName: internal_normalizeSystemFunctionName(systemId, functionName),
-      args
-    })
-  ];
-}
-
-// ts/encodeSystemCallFrom.ts
-var import_viem2 = require("viem");
-function encodeSystemCallFrom({
-  abi,
-  from,
-  systemId,
-  functionName,
-  args
-}) {
-  return [
-    from,
-    systemId,
-    (0, import_viem2.encodeFunctionData)({
-      abi,
-      functionName: internal_normalizeSystemFunctionName(systemId, functionName),
-      args
-    })
-  ];
-}
-
-// ts/encodeSystemCalls.ts
-var import_viem3 = require("viem");
-function encodeSystemCalls(abi, systemCalls) {
-  return [
-    systemCalls.map(({ systemId, functionName, args }) => ({
-      systemId,
-      callData: (0, import_viem3.encodeFunctionData)({
-        abi,
-        functionName: internal_normalizeSystemFunctionName(systemId, functionName),
-        args
-      })
-    }))
-  ];
-}
-
-// ts/encodeSystemCallsFrom.ts
-var import_viem4 = require("viem");
-function encodeSystemCallsFrom(abi, from, systemCalls) {
-  return [
-    systemCalls.map(({ systemId, functionName, args }) => ({
-      from,
-      systemId,
-      callData: (0, import_viem4.encodeFunctionData)({
-        abi,
-        functionName: internal_normalizeSystemFunctionName(systemId, functionName),
-        args
-      })
-    }))
-  ];
-}
-
-// ts/actions/callFrom.ts
-var import_viem5 = require("viem");
-var import_utils2 = require("viem/utils");
-var import_actions = require("viem/actions");
-var import_common3 = require("@latticexyz/common");
-var import_internal8 = require("@latticexyz/protocol-parser/internal");
-
-// ts/config/v2/world.ts
-var import_internal7 = require("@latticexyz/store/internal");
-
-// ts/config/v2/defaults.ts
-var SYSTEM_DEPLOY_DEFAULTS = {
-  disabled: false,
-  registerWorldFunctions: true
-};
-var SYSTEM_DEFAULTS = {
-  namespaceLabel: "",
-  openAccess: true,
-  accessList: []
-};
-var MODULE_DEFAULTS = {
-  root: false,
-  args: [],
-  artifactPath: void 0
-};
-var CODEGEN_DEFAULTS = {
-  worldInterfaceName: "IWorld",
-  worldgenDirectory: "world",
-  systemLibrariesDirectory: "systems",
-  generateSystemLibraries: false,
-  worldImportPath: "@latticexyz/world/src"
-};
-var DEPLOY_DEFAULTS = {
-  postDeployScript: "PostDeploy",
-  deploysDirectory: "./deploys",
-  worldsFile: "./worlds.json",
-  upgradeableWorldImplementation: false
-};
-var CONFIG_DEFAULTS = {
-  systems: {},
-  tables: {},
-  excludeSystems: [],
-  modules: [],
-  codegen: CODEGEN_DEFAULTS,
-  deploy: DEPLOY_DEFAULTS
-};
-
-// ts/config/v2/systems.ts
-var import_internal2 = require("@latticexyz/store/internal");
-
-// ts/config/v2/system.ts
-var import_internal = require("@latticexyz/store/internal");
-var import_common2 = require("@latticexyz/common");
-function validateSystem(input, options = {}) {
-  if (typeof input !== "object" || input == null) {
-    throw new Error(`Expected full system config, got \`${JSON.stringify(input)}\``);
-  }
-  if (options.inNamespace && ((0, import_internal.hasOwnKey)(input, "label") || (0, import_internal.hasOwnKey)(input, "namespaceLabel") || (0, import_internal.hasOwnKey)(input, "namespace"))) {
-    throw new Error(
-      "Overrides of `label`, `namespaceLabel`, and `namespace` are not allowed for systems in this context."
-    );
-  }
-  if ((0, import_internal.hasOwnKey)(input, "namespaceLabel") && typeof input.namespaceLabel === "string" && (!(0, import_internal.hasOwnKey)(input, "namespace") || typeof input.namespace !== "string") && input.namespaceLabel.length > 14) {
-    throw new Error(
-      `System \`namespace\` defaults to \`namespaceLabel\`, but must fit into a \`bytes14\` and "${input.namespaceLabel}" is too long. Provide explicit \`namespace\` override.`
-    );
-  }
-  if ((0, import_internal.hasOwnKey)(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
-    throw new Error(`System \`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
-  }
-  if ((0, import_internal.hasOwnKey)(input, "name") && typeof input.name === "string" && input.name.length > 16) {
-    throw new Error(`System \`name\` must fit into a \`bytes16\`, but "${input.name}" is too long.`);
-  }
-}
-function resolveSystem(input) {
-  const namespaceLabel = input.namespaceLabel ?? SYSTEM_DEFAULTS.namespaceLabel;
-  const namespace = input.namespace ?? namespaceLabel;
-  const label = input.label;
-  const name = input.name ?? label.slice(0, 16);
-  const systemId = (0, import_common2.resourceToHex)({ type: "system", namespace, name });
-  return (0, import_internal.mergeIfUndefined)(
-    {
-      ...input,
-      label,
-      namespaceLabel,
-      namespace,
-      name,
-      systemId,
-      deploy: (0, import_internal.mergeIfUndefined)(input.deploy ?? {}, SYSTEM_DEPLOY_DEFAULTS)
-    },
-    SYSTEM_DEFAULTS
-  );
-}
-function defineSystem(input) {
-  validateSystem(input);
-  return resolveSystem(input);
-}
-
-// ts/config/v2/systems.ts
-function validateSystems(input) {
-  if ((0, import_internal2.isObject)(input)) {
-    for (const system of Object.values(input)) {
-      validateSystem(system, { inNamespace: true });
-    }
-    return;
-  }
-  throw new Error(`Expected system config, received ${JSON.stringify(input)}`);
-}
-function resolveSystems(systems, namespaceLabel, namespace) {
-  return Object.fromEntries(
-    Object.entries(systems).map(([label, system]) => {
-      return [label, resolveSystem({ ...system, label, namespaceLabel, namespace })];
-    })
-  );
-}
-
-// ts/config/v2/namespaces.ts
-var import_util = require("@ark/util");
-
-// ts/config/v2/namespace.ts
-var import_internal3 = require("@latticexyz/store/internal");
-function validateNamespace(input, scope) {
-  if ((0, import_internal3.hasOwnKey)(input, "systems")) {
-    validateSystems(input.systems);
-  }
-  (0, import_internal3.validateNamespace)(input, scope);
-}
-function resolveNamespace(input, scope = import_internal3.AbiTypeScope) {
-  const namespace = (0, import_internal3.resolveNamespace)(input, scope);
-  const systems = resolveSystems(input.systems ?? {}, namespace.label, namespace.namespace);
-  return {
-    ...namespace,
-    systems
-  };
-}
-
-// ts/config/v2/namespaces.ts
-var import_utils = require("@latticexyz/common/utils");
-var import_internal4 = require("@latticexyz/store/internal");
-function validateNamespaces(namespaces, scope) {
-  if (!(0, import_internal4.isObject)(namespaces)) {
-    throw new Error(`Expected namespaces, received ${JSON.stringify(namespaces)}`);
-  }
-  for (const namespace of Object.values(namespaces)) {
-    validateNamespace(namespace, scope);
-  }
-}
-function resolveNamespaces(input, scope) {
-  if (!(0, import_internal4.isObject)(input)) {
-    throw new Error(`Expected namespaces config, received ${JSON.stringify(input)}`);
-  }
-  const namespaces = (0, import_util.flatMorph)(input, (label, namespace) => [
-    label,
-    resolveNamespace((0, import_internal4.mergeIfUndefined)(namespace, { label }), scope)
-  ]);
-  const duplicates = Array.from((0, import_utils.groupBy)(Object.values(namespaces), (namespace) => namespace.namespace).entries()).filter(([, entries]) => entries.length > 1).map(([namespace]) => namespace);
-  if (duplicates.length > 0) {
-    throw new Error(`Found namespaces defined more than once in config: ${duplicates.join(", ")}`);
-  }
-  return namespaces;
-}
-function defineNamespaces(input, scope = import_internal4.AbiTypeScope) {
-  validateNamespaces(input, scope);
-  return resolveNamespaces(input, scope);
-}
-
-// ts/config/v2/codegen.ts
-var import_internal5 = require("@latticexyz/store/internal");
-function resolveCodegen(codegen) {
-  return (0, import_internal5.isObject)(codegen) ? (0, import_internal5.mergeIfUndefined)(codegen, CODEGEN_DEFAULTS) : CODEGEN_DEFAULTS;
-}
-
-// ts/config/v2/deploy.ts
-var import_internal6 = require("@latticexyz/store/internal");
-function resolveDeploy(deploy) {
-  return (0, import_internal6.isObject)(deploy) ? (0, import_internal6.mergeIfUndefined)(deploy, DEPLOY_DEFAULTS) : DEPLOY_DEFAULTS;
-}
-
-// ts/config/v2/world.ts
-function validateWorld(input) {
-  const scope = (0, import_internal7.extendedScope)(input);
-  if ((0, import_internal7.hasOwnKey)(input, "namespaces")) {
-    if ((0, import_internal7.hasOwnKey)(input, "namespace") || (0, import_internal7.hasOwnKey)(input, "tables") || (0, import_internal7.hasOwnKey)(input, "systems")) {
-      throw new Error("Cannot use `namespaces` with `namespace`, `tables`, or `systems` keys.");
-    }
-    validateNamespaces(input.namespaces, scope);
-  }
-  if ((0, import_internal7.hasOwnKey)(input, "systems")) {
-    validateSystems(input.systems);
-  }
-  (0, import_internal7.validateStore)(input);
-}
-function resolveWorld(input) {
-  const scope = (0, import_internal7.extendedScope)(input);
-  const store = (0, import_internal7.resolveStore)(input);
-  const namespaces = input.namespaces ? resolveNamespaces(input.namespaces, scope) : resolveNamespaces({ [store.namespace]: input }, scope);
-  const tables = (0, import_internal7.flattenNamespacedTables)({ namespaces });
-  const modules = (input.modules ?? CONFIG_DEFAULTS.modules).map((mod) => (0, import_internal7.mergeIfUndefined)(mod, MODULE_DEFAULTS));
-  return (0, import_internal7.mergeIfUndefined)(
-    {
-      ...store,
-      namespaces,
-      tables,
-      // TODO: flatten systems from namespaces
-      systems: !store.multipleNamespaces && input.systems ? resolveSystems(input.systems, store.namespace, store.namespace) : CONFIG_DEFAULTS.systems,
-      excludeSystems: (0, import_internal7.get)(input, "excludeSystems"),
-      codegen: (0, import_internal7.mergeIfUndefined)(store.codegen, resolveCodegen(input.codegen)),
-      deploy: resolveDeploy(input.deploy),
-      modules
-    },
-    CONFIG_DEFAULTS
-  );
-}
-function defineWorld(input) {
-  validateWorld(input);
-  return resolveWorld(input);
-}
-
-// mud.config.ts
-var configInput = {
-  namespace: "world",
-  // NOTE: this namespace is only used for tables, the core system is deployed in the root namespace.
-  codegen: {
-    worldImportPath: "./src",
-    worldgenDirectory: "interfaces",
-    worldInterfaceName: "IBaseWorld"
-  },
-  userTypes: {
-    ResourceId: { filePath: "@latticexyz/store/src/ResourceId.sol", type: "bytes32" }
-  },
-  tables: {
-    NamespaceOwner: {
-      schema: {
-        namespaceId: "ResourceId",
-        owner: "address"
-      },
-      key: ["namespaceId"]
-    },
-    ResourceAccess: {
-      schema: {
-        resourceId: "ResourceId",
-        caller: "address",
-        access: "bool"
-      },
-      key: ["resourceId", "caller"]
-    },
-    InstalledModules: {
-      schema: {
-        moduleAddress: "address",
-        argumentsHash: "bytes32",
-        // Hash of the params passed to the `install` function
-        isInstalled: "bool"
-      },
-      key: ["moduleAddress", "argumentsHash"]
-    },
-    UserDelegationControl: {
-      schema: {
-        delegator: "address",
-        delegatee: "address",
-        delegationControlId: "ResourceId"
-      },
-      key: ["delegator", "delegatee"]
-    },
-    NamespaceDelegationControl: {
-      schema: {
-        namespaceId: "ResourceId",
-        delegationControlId: "ResourceId"
-      },
-      key: ["namespaceId"]
-    },
-    Balances: {
-      schema: {
-        namespaceId: "ResourceId",
-        balance: "uint256"
-      },
-      key: ["namespaceId"]
-    },
-    Systems: {
-      schema: {
-        systemId: "ResourceId",
-        system: "address",
-        publicAccess: "bool"
-      },
-      key: ["systemId"],
-      codegen: {
-        dataStruct: false
-      }
-    },
-    SystemRegistry: {
-      schema: {
-        system: "address",
-        systemId: "ResourceId"
-      },
-      key: ["system"]
-    },
-    SystemHooks: {
-      schema: {
-        systemId: "ResourceId",
-        value: "bytes21[]"
-      },
-      key: ["systemId"]
-    },
-    FunctionSelectors: {
-      schema: {
-        worldFunctionSelector: "bytes4",
-        systemId: "ResourceId",
-        systemFunctionSelector: "bytes4"
-      },
-      key: ["worldFunctionSelector"],
-      codegen: {
-        dataStruct: false
-      }
-    },
-    FunctionSignatures: {
-      type: "offchainTable",
-      schema: {
-        functionSelector: "bytes4",
-        functionSignature: "string"
-      },
-      key: ["functionSelector"]
-    },
-    InitModuleAddress: {
-      schema: {
-        value: "address"
-      },
-      key: []
-    }
-  },
-  excludeSystems: [
-    // Worldgen currently does not support systems inheriting logic
-    // from other contracts, so all parts of RegistrationSystem are named
-    // System too to be included in the IBaseWorld interface.
-    // However, IStoreRegistrationSystem overlaps with IStore if
-    // included in IBaseWorld, so it needs to be excluded from worldgen.
-    // TODO: add support for inheritance to worldgen
-    // (see: https://github.com/latticexyz/mud/issues/631)
-    "StoreRegistrationSystem"
-  ]
-};
-var mud_config_default = defineWorld(configInput);
-
-// ts/actions/callFrom.ts
-function callFrom(params) {
-  return (client) => ({
-    async writeContract(writeArgs) {
-      const _writeContract = (0, import_utils2.getAction)(client, import_actions.writeContract, "writeContract");
-      if (writeArgs.address !== params.worldAddress || writeArgs.functionName === "call" || writeArgs.functionName === "callFrom" || writeArgs.functionName === "batchCallFrom" || writeArgs.functionName === "callWithSignature") {
-        return _writeContract(writeArgs);
-      }
-      if (writeArgs.functionName === "batchCall") {
-        const batchCallArgs = writeArgs;
-        const [systemCalls] = batchCallArgs.args;
-        if (!systemCalls.length) {
-          throw new Error("`batchCall` should have at least one system call.");
-        }
-        return _writeContract({
-          ...batchCallArgs,
-          functionName: "batchCallFrom",
-          args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))]
-        });
-      }
-      const worldCalldata = (0, import_utils2.encodeFunctionData)({
-        abi: writeArgs.abi,
-        functionName: writeArgs.functionName,
-        args: writeArgs.args
-      });
-      const worldFunctionSelector = (0, import_viem5.slice)(worldCalldata, 0, 4);
-      const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({
-        ...params,
-        publicClient: params.publicClient ?? client,
-        worldFunctionSelector
-      });
-      const systemCalldata = (0, import_viem5.concat)([systemFunctionSelector, (0, import_common3.readHex)(worldCalldata, 4)]);
-      return _writeContract({
-        ...writeArgs,
-        functionName: "callFrom",
-        args: [params.delegatorAddress, systemId, systemCalldata]
-      });
-    }
-  });
-}
-var systemFunctionCache = /* @__PURE__ */ new Map();
-async function worldFunctionToSystemFunction(params) {
-  const cacheKey = (0, import_viem5.concat)([params.worldAddress, params.worldFunctionSelector]);
-  const cached = systemFunctionCache.get(cacheKey);
-  if (cached) return cached;
-  const systemFunction = params.worldFunctionToSystemFunction ? await params.worldFunctionToSystemFunction(params.worldFunctionSelector) : await retrieveSystemFunctionFromContract(params.publicClient, params.worldAddress, params.worldFunctionSelector);
-  systemFunctionCache.set(cacheKey, systemFunction);
-  return systemFunction;
-}
-async function retrieveSystemFunctionFromContract(publicClient, worldAddress, worldFunctionSelector) {
-  const table = mud_config_default.tables.world__FunctionSelectors;
-  const keySchema = (0, import_internal8.getSchemaTypes)((0, import_internal8.getKeySchema)(table));
-  const valueSchema = (0, import_internal8.getSchemaTypes)((0, import_internal8.getValueSchema)(table));
-  const _readContract = (0, import_utils2.getAction)(publicClient, import_actions.readContract, "readContract");
-  const [staticData, encodedLengths, dynamicData] = await _readContract({
-    address: worldAddress,
-    abi: [
-      {
-        type: "function",
-        name: "getRecord",
-        inputs: [
-          {
-            name: "tableId",
-            type: "bytes32",
-            internalType: "ResourceId"
-          },
-          {
-            name: "keyTuple",
-            type: "bytes32[]",
-            internalType: "bytes32[]"
-          }
-        ],
-        outputs: [
-          {
-            name: "staticData",
-            type: "bytes",
-            internalType: "bytes"
-          },
-          {
-            name: "encodedLengths",
-            type: "bytes32",
-            internalType: "EncodedLengths"
-          },
-          {
-            name: "dynamicData",
-            type: "bytes",
-            internalType: "bytes"
-          }
-        ],
-        stateMutability: "view"
-      }
-    ],
-    functionName: "getRecord",
-    args: [table.tableId, (0, import_internal8.encodeKey)(keySchema, { worldFunctionSelector })]
-  });
-  const decoded = (0, import_internal8.decodeValueArgs)(valueSchema, { staticData, encodedLengths, dynamicData });
-  const systemFunction = {
-    systemId: decoded.systemId,
-    systemFunctionSelector: decoded.systemFunctionSelector
-  };
-  return systemFunction;
-}
-
-// ts/config/v2/dynamicResolution.ts
-function resolveTableId(tableName) {
-  return {
-    type: "tableId",
-    input: tableName
-  };
-}
-function isDynamicResolution(value) {
-  return typeof value === "object" && value !== null && "type" in value && "input" in value;
-}
-function isValueWithType(value) {
-  return typeof value === "object" && value !== null && "type" in value && "value" in value;
-}
-function resolveWithContext(input, context) {
-  if (isValueWithType(input)) return input;
-  if (isDynamicResolution(input)) {
-    if (input.type === "tableId") {
-      const tableEntries = Object.entries(context.config.tables).filter(
-        ([tableName, table]) => tableName === input.input || table.name === input.input
-      );
-      if (tableEntries.length > 1) {
-        throw new Error(
-          `Found more than one table with name "${input.input}". Try using one of the following table names instead: ${tableEntries.map(([tableName]) => tableName).join(", ")}`
-        );
-      }
-      if (tableEntries.length === 1) {
-        const [entry] = tableEntries;
-        const [, table] = entry;
-        return { type: "bytes32", value: table.tableId };
-      }
-    }
-  }
-  throw new Error(`Could not resolve dynamic resolution:
-${JSON.stringify(input, null, 2)}`);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CODEGEN_DEFAULTS,
-  CONFIG_DEFAULTS,
-  DEPLOY_DEFAULTS,
-  MODULE_DEFAULTS,
-  SYSTEM_DEFAULTS,
-  SYSTEM_DEPLOY_DEFAULTS,
-  callFrom,
-  defineNamespaces,
-  defineSystem,
-  defineWorld,
-  encodeSystemCall,
-  encodeSystemCallFrom,
-  encodeSystemCalls,
-  encodeSystemCallsFrom,
-  isDynamicResolution,
-  isValueWithType,
-  resolveCodegen,
-  resolveDeploy,
-  resolveNamespace,
-  resolveNamespaces,
-  resolveSystem,
-  resolveSystems,
-  resolveTableId,
-  resolveWithContext,
-  resolveWorld,
-  validateNamespace,
-  validateNamespaces,
-  validateSystem,
-  validateSystems,
-  validateWorld
-});
-//# sourceMappingURL=internal.cjs.map