@latticexyz/world 2.2.18-90aac1d4acce19ac592d47a090732dd11c1c3e7a → 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2

package/dist/internal.cjs

@@ -0,0 +1,656 @@
+"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