@webstudio-is/react-sdk 0.90.0 → 0.92.0

package/lib/cjs/expression.js

@@ -1,371 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var expression_exports = {};
-__export(expression_exports, {
-  computeExpressionsDependencies: () => computeExpressionsDependencies,
-  decodeDataSourceVariable: () => decodeDataSourceVariable,
-  decodeVariablesMap: () => decodeVariablesMap,
-  encodeDataSourceVariable: () => encodeDataSourceVariable,
-  encodeVariablesMap: () => encodeVariablesMap,
-  executeComputingExpressions: () => executeComputingExpressions,
-  executeEffectfulExpression: () => executeEffectfulExpression,
-  generateComputingExpressions: () => generateComputingExpressions,
-  generateEffectfulExpression: () => generateEffectfulExpression,
-  validateExpression: () => validateExpression
-});
-module.exports = __toCommonJS(expression_exports);
-var import_jsep = __toESM(require("jsep"), 1);
-var import_assignment = __toESM(require("@jsep-plugin/assignment"), 1);
-import_jsep.default.plugins.register(import_assignment.default);
-const generateCode = (node, failOnForbidden, effectful, transformIdentifier) => {
-  if (node.type === "Identifier") {
-    return transformIdentifier(node.name, false);
-  }
-  if (node.type === "MemberExpression") {
-    if (failOnForbidden) {
-      const object2 = generateCode(
-        node.object,
-        false,
-        effectful,
-        transformIdentifier
-      );
-      const property2 = generateCode(
-        node.property,
-        false,
-        effectful,
-        transformIdentifier
-      );
-      throw Error(`Cannot access "${property2}" of "${object2}"`);
-    }
-    const object = generateCode(
-      node.object,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    const property = generateCode(
-      node.property,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${object}.${property}`;
-  }
-  if (node.type === "Literal") {
-    return node.raw;
-  }
-  if (node.type === "UnaryExpression") {
-    const arg = generateCode(
-      node.argument,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${node.operator}${arg}`;
-  }
-  if (node.type === "BinaryExpression") {
-    const left = generateCode(
-      node.left,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    const right = generateCode(
-      node.right,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${left} ${node.operator} ${right}`;
-  }
-  if (node.type === "ArrayExpression") {
-    const elements = node.elements.map(
-      (element) => generateCode(
-        element,
-        failOnForbidden,
-        effectful,
-        transformIdentifier
-      )
-    );
-    return `[${elements.join(", ")}]`;
-  }
-  if (node.type === "CallExpression") {
-    if (failOnForbidden) {
-      const callee2 = generateCode(
-        node.callee,
-        false,
-        effectful,
-        transformIdentifier
-      );
-      throw Error(`Cannot call "${callee2}"`);
-    }
-    const callee = generateCode(
-      node.callee,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    const args = node.arguments.map(
-      (arg) => generateCode(arg, failOnForbidden, effectful, transformIdentifier)
-    );
-    return `${callee}(${args.join(", ")})`;
-  }
-  if (node.type === "ThisExpression") {
-    if (failOnForbidden) {
-      throw Error(`"this" is not supported`);
-    }
-    return "this";
-  }
-  if (node.type === "ConditionalExpression") {
-    throw Error("Ternary operator is not supported");
-  }
-  if (node.type === "Compound") {
-    throw Error("Cannot use multiple expressions");
-  }
-  if (node.type === "AssignmentExpression") {
-    if (node.operator !== "=") {
-      throw Error(`Only "=" assignment operator is supported`);
-    }
-    if (effectful === false) {
-      throw Error(`Cannot use assignment in this expression`);
-    }
-    const left = generateCode(
-      node.left,
-      failOnForbidden,
-      effectful,
-      // override and mark all identifiers inside of left expression as assignee
-      (id) => transformIdentifier(id, true)
-    );
-    const right = generateCode(
-      node.right,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${left} ${node.operator} ${right}`;
-  }
-  if (node.type === "UpdateExpression") {
-    throw Error(`"${node.operator}" operator is not supported`);
-  }
-  node;
-  return "";
-};
-const validateExpression = (code, options) => {
-  const { effectful = false, transformIdentifier = (id) => id } = options ?? {};
-  const expression = (0, import_jsep.default)(code);
-  return generateCode(expression, true, effectful, transformIdentifier);
-};
-const sortTopologically = (list, depsById, explored = /* @__PURE__ */ new Set(), sorted = []) => {
-  for (const id of list) {
-    if (explored.has(id)) {
-      continue;
-    }
-    explored.add(id);
-    const deps = depsById.get(id);
-    if (deps) {
-      sortTopologically(deps, depsById, explored, sorted);
-    }
-    sorted.push(id);
-  }
-  return sorted;
-};
-const generateComputingExpressions = (expressions, allowedVariables) => {
-  const depsById = /* @__PURE__ */ new Map();
-  const inputVariables = /* @__PURE__ */ new Set();
-  for (const [id, code] of expressions) {
-    const deps = /* @__PURE__ */ new Set();
-    validateExpression(code, {
-      transformIdentifier: (identifier) => {
-        if (allowedVariables.has(identifier)) {
-          inputVariables.add(identifier);
-          return identifier;
-        }
-        if (expressions.has(identifier)) {
-          deps.add(identifier);
-          return identifier;
-        }
-        throw Error(`Unknown dependency "${identifier}"`);
-      }
-    });
-    depsById.set(id, deps);
-  }
-  const sortedExpressions = sortTopologically(
-    new Set(expressions.keys()),
-    depsById
-  );
-  let generatedCode = "";
-  for (const id of inputVariables) {
-    generatedCode += `const ${id} = _variables.get('${id}');
-`;
-  }
-  for (const id of sortedExpressions) {
-    const code = expressions.get(id);
-    if (code === void 0) {
-      continue;
-    }
-    generatedCode += `const ${id} = (${code});
-`;
-  }
-  generatedCode += `return new Map([
-`;
-  for (const id of sortedExpressions) {
-    generatedCode += `  ['${id}', ${id}],
-`;
-  }
-  generatedCode += `]);`;
-  return generatedCode;
-};
-const executeComputingExpressions = (expressions, variables) => {
-  const generatedCode = generateComputingExpressions(
-    expressions,
-    new Set(variables.keys())
-  );
-  const executeFn = new Function("_variables", generatedCode);
-  const values = executeFn(variables);
-  return values;
-};
-const generateEffectfulExpression = (code, args, allowedVariables) => {
-  const inputVariables = /* @__PURE__ */ new Set();
-  const outputVariables = /* @__PURE__ */ new Set();
-  validateExpression(code, {
-    effectful: true,
-    transformIdentifier: (identifier, assignee) => {
-      if (args.has(identifier)) {
-        return identifier;
-      }
-      if (allowedVariables.has(identifier)) {
-        if (assignee) {
-          outputVariables.add(identifier);
-        } else {
-          inputVariables.add(identifier);
-        }
-        return identifier;
-      }
-      throw Error(`Unknown dependency "${identifier}"`);
-    }
-  });
-  let generatedCode = "";
-  for (const id of args) {
-    generatedCode += `let ${id} = _args.get('${id}');
-`;
-  }
-  for (const id of inputVariables) {
-    generatedCode += `let ${id} = _variables.get('${id}');
-`;
-  }
-  for (const id of outputVariables) {
-    if (inputVariables.has(id) === false) {
-      generatedCode += `let ${id};
-`;
-    }
-  }
-  generatedCode += `${code};
-`;
-  generatedCode += `return new Map([
-`;
-  for (const id of outputVariables) {
-    generatedCode += `  ['${id}', ${id}],
-`;
-  }
-  generatedCode += `]);`;
-  return generatedCode;
-};
-const executeEffectfulExpression = (code, args, variables) => {
-  const generatedCode = generateEffectfulExpression(
-    code,
-    new Set(args.keys()),
-    new Set(variables.keys())
-  );
-  const executeFn = new Function("_variables", "_args", generatedCode);
-  const values = executeFn(variables, args);
-  return values;
-};
-const computeExpressionDependencies = (expressions, expressionId, dependencies) => {
-  const depsById = dependencies.get(expressionId);
-  if (depsById) {
-    return depsById;
-  }
-  const parentDeps = /* @__PURE__ */ new Set();
-  const code = expressions.get(expressionId);
-  if (code === void 0) {
-    return parentDeps;
-  }
-  dependencies.set(expressionId, parentDeps);
-  validateExpression(code, {
-    transformIdentifier: (id) => {
-      parentDeps.add(id);
-      const childDeps = computeExpressionDependencies(
-        expressions,
-        id,
-        dependencies
-      );
-      for (const depId of childDeps) {
-        parentDeps.add(depId);
-      }
-      return id;
-    }
-  });
-  return parentDeps;
-};
-const computeExpressionsDependencies = (expressions) => {
-  const dependencies = /* @__PURE__ */ new Map();
-  for (const id of expressions.keys()) {
-    computeExpressionDependencies(expressions, id, dependencies);
-  }
-  return dependencies;
-};
-const dataSourceVariablePrefix = "$ws$dataSource$";
-const encodeDataSourceVariable = (id) => {
-  const encoded = id.replaceAll("-", "__DASH__");
-  return `${dataSourceVariablePrefix}${encoded}`;
-};
-const encodeVariablesMap = (values) => {
-  const encodedValues = /* @__PURE__ */ new Map();
-  for (const [id, value] of values) {
-    encodedValues.set(encodeDataSourceVariable(id), value);
-  }
-  return encodedValues;
-};
-const decodeDataSourceVariable = (name) => {
-  if (name.startsWith(dataSourceVariablePrefix)) {
-    const encoded = name.slice(dataSourceVariablePrefix.length);
-    return encoded.replaceAll("__DASH__", "-");
-  }
-  return;
-};
-const decodeVariablesMap = (values) => {
-  const decodedValues = /* @__PURE__ */ new Map();
-  for (const [name, value] of values) {
-    const id = decodeDataSourceVariable(name);
-    if (id !== void 0) {
-      decodedValues.set(id, value);
-    }
-  }
-  return decodedValues;
-};

package/lib/cjs/generator.js

@@ -1,128 +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);
-var generator_exports = {};
-__export(generator_exports, {
-  generateUtilsExport: () => generateUtilsExport
-});
-module.exports = __toCommonJS(generator_exports);
-var import_instance_utils = require("./instance-utils");
-var import_expression = require("./expression");
-const generateUtilsExport = (siteData) => {
-  const indexesWithinAncestors = (0, import_instance_utils.getIndexesWithinAncestors)(
-    siteData.metas,
-    siteData.instances,
-    [siteData.page.rootInstanceId]
-  );
-  let indexesWithinAncestorsEntries = "";
-  for (const [key, value] of indexesWithinAncestors) {
-    const keyString = JSON.stringify(key);
-    const valueString = JSON.stringify(value);
-    indexesWithinAncestorsEntries += `[${keyString}, ${valueString}],
-`;
-  }
-  const generatedIndexesWithinAncestors = `
-  const indexesWithinAncestors = new Map<string, number>([
-  ${indexesWithinAncestorsEntries}
-  ]);
-  `;
-  const variables = /* @__PURE__ */ new Set();
-  const expressions = /* @__PURE__ */ new Map();
-  for (const dataSource of siteData.dataSources.values()) {
-    if (dataSource.type === "variable") {
-      variables.add((0, import_expression.encodeDataSourceVariable)(dataSource.id));
-    }
-    if (dataSource.type === "expression") {
-      expressions.set((0, import_expression.encodeDataSourceVariable)(dataSource.id), dataSource.code);
-    }
-  }
-  const generatedExecuteComputingExpressions = `
-  const rawExecuteComputingExpressions = (
-    _variables: Map<string, unknown>
-  ): Map<string, unknown> => {
-    ${(0, import_expression.generateComputingExpressions)(expressions, variables)}
-  };
-  const executeComputingExpressions = (variables: Map<string, unknown>) => {
-    const encodedvariables = sdk.encodeVariablesMap(variables);
-    const encodedResult = rawExecuteComputingExpressions(encodedvariables);
-    return sdk.decodeVariablesMap(encodedResult);
-  };
-  `;
-  let effectfulExpressionsEntries = "";
-  for (const prop of siteData.props.values()) {
-    if (prop.type === "action") {
-      for (const executableValue of prop.value) {
-        const codeString = JSON.stringify(executableValue.code);
-        const generatedCode = (0, import_expression.generateEffectfulExpression)(
-          executableValue.code,
-          new Set(executableValue.args),
-          variables
-        );
-        const generatedFunction = `(_args: Map<string, any>, _variables: Map<string, any>) => { ${generatedCode} }`;
-        effectfulExpressionsEntries += `[${codeString}, ${generatedFunction}],
-`;
-      }
-    }
-  }
-  const generatedExecuteEffectfulExpression = `const generatedEffectfulExpressions = new Map<
-    string,
-    (args: Map<string, any>, variables: Map<string, any>) => Map<string, unknown>
-  >([
-  ${effectfulExpressionsEntries}
-  ]);
-
-  const rawExecuteEffectfulExpression = (
-    code: string,
-    args: Map<string, unknown>,
-    variables: Map<string, unknown>
-  ): Map<string, unknown> => {
-    if(generatedEffectfulExpressions.has(code)) {
-      return generatedEffectfulExpressions.get(code)!(args, variables);
-    }
-    console.error("Effectful expression not found", code);
-    throw new Error("Effectful expression not found");
-  };
-
-  const executeEffectfulExpression = (
-    code: string,
-    args: Map<string, unknown>,
-    variables: Map<string, unknown>
-  ) => {
-    const encodedvariables = sdk.encodeVariablesMap(variables);
-    const encodedResult = rawExecuteEffectfulExpression(code, args, encodedvariables);
-    return sdk.decodeVariablesMap(encodedResult);
-  };
-  `;
-  return `
-  /* eslint-disable */
-
-  ${generatedIndexesWithinAncestors.trim()}
-
-  ${generatedExecuteComputingExpressions.trim()}
-
-  ${generatedExecuteEffectfulExpression.trim()}
-
-  export const utils = {
-    indexesWithinAncestors,
-    executeComputingExpressions,
-    executeEffectfulExpression,
-  };
-
-  /* eslint-enable */
-  `;
-};

package/lib/cjs/hook.js

@@ -1,34 +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);
-var hook_exports = {};
-__export(hook_exports, {
-  getClosestInstance: () => getClosestInstance
-});
-module.exports = __toCommonJS(hook_exports);
-const getClosestInstance = (instancePath, currentInstance, closestComponent) => {
-  let matched = false;
-  for (const instance of instancePath) {
-    if (currentInstance === instance) {
-      matched = true;
-    }
-    if (matched && instance.component === closestComponent) {
-      return instance;
-    }
-  }
-};

package/lib/cjs/index.js

@@ -1,59 +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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-__export(src_exports, {
-  ReactSdkContext: () => import_context.ReactSdkContext,
-  componentCategories: () => import_component_meta.componentCategories,
-  computeExpressionsDependencies: () => import_expression.computeExpressionsDependencies,
-  decodeDataSourceVariable: () => import_expression.decodeDataSourceVariable,
-  decodeVariablesMap: () => import_expression.decodeVariablesMap,
-  defaultStates: () => import_component_meta.defaultStates,
-  encodeDataSourceVariable: () => import_expression.encodeDataSourceVariable,
-  encodeVariablesMap: () => import_expression.encodeVariablesMap,
-  executeComputingExpressions: () => import_expression.executeComputingExpressions,
-  executeEffectfulExpression: () => import_expression.executeEffectfulExpression,
-  generateComputingExpressions: () => import_expression.generateComputingExpressions,
-  generateEffectfulExpression: () => import_expression.generateEffectfulExpression,
-  generateUtilsExport: () => import_generator.generateUtilsExport,
-  getIndexWithinAncestorFromComponentProps: () => import_props.getIndexWithinAncestorFromComponentProps,
-  getIndexesWithinAncestors: () => import_instance_utils.getIndexesWithinAncestors,
-  getInstanceIdFromComponentProps: () => import_props.getInstanceIdFromComponentProps,
-  renderComponentTemplate: () => import_component_renderer.renderComponentTemplate,
-  stateCategories: () => import_component_meta.stateCategories,
-  useInstanceProps: () => import_props.useInstanceProps,
-  usePropAsset: () => import_props.usePropAsset,
-  usePropUrl: () => import_props.usePropUrl,
-  validateExpression: () => import_expression.validateExpression
-});
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./css"), module.exports);
-__reExport(src_exports, require("./tree"), module.exports);
-__reExport(src_exports, require("./pubsub"), module.exports);
-__reExport(src_exports, require("./app"), module.exports);
-__reExport(src_exports, require("./components/components-utils"), module.exports);
-var import_component_meta = require("./components/component-meta");
-__reExport(src_exports, require("./embed-template"), module.exports);
-var import_props = require("./props");
-var import_context = require("./context");
-var import_expression = require("./expression");
-var import_component_renderer = require("./component-renderer");
-var import_instance_utils = require("./instance-utils");
-__reExport(src_exports, require("./hook"), module.exports);
-var import_generator = require("./generator");

package/lib/cjs/instance-utils.js

@@ -1,65 +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);
-var instance_utils_exports = {};
-__export(instance_utils_exports, {
-  getIndexesWithinAncestors: () => getIndexesWithinAncestors
-});
-module.exports = __toCommonJS(instance_utils_exports);
-const getIndexesWithinAncestors = (metas, instances, rootIds) => {
-  const ancestors = /* @__PURE__ */ new Set();
-  for (const meta of metas.values()) {
-    if (meta.indexWithinAncestor !== void 0) {
-      ancestors.add(meta.indexWithinAncestor);
-    }
-  }
-  const indexes = /* @__PURE__ */ new Map();
-  const traverseInstances = (instances2, instanceId, latestIndexes2 = /* @__PURE__ */ new Map()) => {
-    const instance = instances2.get(instanceId);
-    if (instance === void 0) {
-      return;
-    }
-    const meta = metas.get(instance.component);
-    if (meta === void 0) {
-      return;
-    }
-    if (ancestors.has(instance.component)) {
-      latestIndexes2 = new Map(latestIndexes2);
-      latestIndexes2.set(instance.component, /* @__PURE__ */ new Map());
-    }
-    if (meta.indexWithinAncestor !== void 0) {
-      const ancestorIndexes = latestIndexes2.get(meta.indexWithinAncestor);
-      if (ancestorIndexes !== void 0) {
-        let index = ancestorIndexes.get(instance.component) ?? -1;
-        index += 1;
-        ancestorIndexes.set(instance.component, index);
-        indexes.set(instance.id, index);
-      }
-    }
-    for (const child of instance.children) {
-      if (child.type === "id") {
-        traverseInstances(instances2, child.value, latestIndexes2);
-      }
-    }
-  };
-  const latestIndexes = /* @__PURE__ */ new Map();
-  for (const instanceId of rootIds) {
-    traverseInstances(instances, instanceId, latestIndexes);
-  }
-  return indexes;
-};

package/lib/cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}