@triflare/fx 1.0.2 → 2.0.0

package/src/config.js

@@ -31,8 +31,112 @@ export const DEFAULT_PROJECT = {
  */
 export const DEFAULT_FX = {
   partialSprites: false,
+  vendorDir: "extensions",
 };
 
+/** Default directory that receives vendored extension sources. */
+export const DEFAULT_VENDOR_DIR = "extensions";
+
+/** Source schemes that identify a remote extension. */
+const REMOTE_SOURCE = /^https?:\/\//i;
+const DATA_SOURCE = /^data:/i;
+
+/** True for http(s) extension sources. */
+function isRemoteSource(source) {
+  return REMOTE_SOURCE.test(String(source));
+}
+
+/** True for embedded data-URI extension sources. */
+function isDataSource(source) {
+  return DATA_SOURCE.test(String(source));
+}
+
+/** Localhost/loopback URLs can point at a development server that changes. */
+export function isLocalhostSource(source) {
+  if (!isRemoteSource(source)) return false;
+  try {
+    const url = new URL(String(source));
+    const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    return (
+      host === "localhost" ||
+      host.endsWith(".localhost") ||
+      host === "0.0.0.0" ||
+      host === "::1" ||
+      /^127\./.test(host)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Normalize one `vendor:` entry. A string is shorthand for `{ url }`; a
+ * mapping may add `unsandboxed`, `volatile` and any future fields.
+ *
+ * @param {string} name
+ * @param {unknown} raw
+ * @returns {object}
+ */
+export function normalizeVendorEntry(name, raw) {
+  const key = String(name);
+  let source;
+  let options = {};
+  if (typeof raw === "string" || typeof raw === "number") {
+    source = String(raw);
+  } else if (isPlainObject(raw)) {
+    source = raw.url ?? raw.source ?? raw.path ?? raw.file;
+    options = { ...raw };
+  } else {
+    throw new Error(
+      `${configFilename()}: vendor.${key} must be a URL, path, or mapping`,
+    );
+  }
+  if (typeof source !== "string" || source.trim() === "")
+    throw new Error(
+      `${configFilename()}: vendor.${key} needs a "url" (or "source"/"path")`,
+    );
+  source = source.trim();
+
+  const remote = isRemoteSource(source);
+  const local = !remote && !isDataSource(source);
+  const unsandboxed =
+    options.unsandboxed === true ||
+    (typeof options.unsandboxed === "string" &&
+      options.unsandboxed.trim() !== "");
+  const volatile =
+    options.volatile == null
+      ? remote && isLocalhostSource(source)
+      : Boolean(options.volatile);
+
+  return {
+    ...options,
+    name: key,
+    source,
+    url: source,
+    remote,
+    local,
+    data: isDataSource(source),
+    volatile,
+    unsandboxed,
+  };
+}
+
+/**
+ * Normalize the top-level `vendor:` mapping. Order is load order, so this is an
+ * array rather than a plain object.
+ *
+ * @param {unknown} raw
+ * @returns {object[]}
+ */
+export function normalizeVendor(raw = {}) {
+  if (raw == null) return [];
+  if (!isPlainObject(raw))
+    throw new Error(`${configFilename()}: "vendor" must be a mapping`);
+  return Object.entries(raw).map(([name, entry]) =>
+    normalizeVendorEntry(name, entry),
+  );
+}
+
 /**
  * Packaging defaults. These never reach PenguinMod itself; they are handed to
  * the PenguinMod Packager when `fx package` or `fx dev` runs.
@@ -281,6 +385,11 @@ export function normalizeFx(raw = {}) {
   if (raw && typeof raw === "object" && !Array.isArray(raw)) {
     if (raw.partialSprites != null)
       fx.partialSprites = Boolean(raw.partialSprites);
+    if (raw.vendorDir != null) {
+      if (typeof raw.vendorDir !== "string" || raw.vendorDir.trim() === "")
+        throw new Error(`${configFilename()}: fx.vendorDir must be a path`);
+      fx.vendorDir = raw.vendorDir.trim();
+    }
   }
   return fx;
 }
@@ -288,7 +397,7 @@ export function normalizeFx(raw = {}) {
 /**
  * Parse a YAML config string.
  * @param {string} text
- * @returns {{project: typeof DEFAULT_PROJECT, fx: typeof DEFAULT_FX, raw: object}}
+ * @returns {{project: typeof DEFAULT_PROJECT, fx: typeof DEFAULT_FX, package: typeof DEFAULT_PACKAGE, vendor: object[], vendorDir: string, raw: object}}
  */
 export function parseConfig(text) {
   const raw = yaml.load(text) || {};
@@ -298,10 +407,20 @@ export function parseConfig(text) {
     );
   if (raw.fx != null && (typeof raw.fx !== "object" || Array.isArray(raw.fx)))
     throw new Error(`${configFilename()} must contain an "fx" mapping`);
+  const fx = normalizeFx(raw.fx || {});
+  // `vendorDir` is documented at the top level, but accepting it under `fx:`
+  // keeps older drafts and long configs working.
+  if (raw.vendorDir != null) {
+    if (typeof raw.vendorDir !== "string" || raw.vendorDir.trim() === "")
+      throw new Error(`${configFilename()}: vendorDir must be a path`);
+    fx.vendorDir = raw.vendorDir.trim();
+  }
   return {
     project: normalizeProject(raw.project || {}),
-    fx: normalizeFx(raw.fx || {}),
+    fx,
     package: normalizePackage(raw.package || {}),
+    vendor: normalizeVendor(raw.vendor || {}),
+    vendorDir: fx.vendorDir,
     raw,
   };
 }
@@ -339,14 +458,26 @@ export function loadConfigFrom(dir) {
       project,
       fx,
       package: pkg,
+      vendor,
+      vendorDir,
       raw,
     } = parseConfig(fs.readFileSync(found, "utf8"));
-    return { project, fx, package: pkg, raw, path: found };
+    return {
+      project,
+      fx,
+      package: pkg,
+      vendor,
+      vendorDir,
+      raw,
+      path: found,
+    };
   }
   return {
     project: { ...DEFAULT_PROJECT },
     fx: { ...DEFAULT_FX },
     package: normalizePackage({}),
+    vendor: [],
+    vendorDir: DEFAULT_VENDOR_DIR,
     raw: {},
     path: null,
   };
@@ -394,7 +525,10 @@ export function configComment(project) {
 
 export {
   addProjectExtension,
+  addVendorEntry,
   extensionKey,
   readProjectExtensions,
   removeProjectExtension,
+  removeProjectExtensions,
+  removeVendorEntry,
 } from "./config-edit.js";

package/src/decompiler.js

@@ -376,13 +376,23 @@ class Decompiler {
     const proto = this.target.blocks[protoId];
     const mutation = (proto && proto.mutation) || {};
     const proccode = mutation.proccode || "procedure";
+    const ids = mutation.argumentids ? JSON.parse(mutation.argumentids) : [];
     const names = mutation.argumentnames
       ? JSON.parse(mutation.argumentnames)
       : [];
+    // Parameter types live on the prototype's argument reporter shadows, not
+    // in the mutation, so read them back or `loud: boolean` decompiles to a
+    // string parameter.
+    const params = names.map((name, index) => {
+      const reporter =
+        proto && this.target.blocks[firstOf(proto.inputs[ids[index]])];
+      return reporter && reporter.opcode === "argument_reporter_boolean"
+        ? `${name}: boolean`
+        : name;
+    });
     const baseName = proccode.split(" ")[0];
     const returning = this.returningProccodes.has(proccode) ? "returning " : "";
-    const params = names.join(", ");
-    return `${returning}function ${baseName}(${params}) {\n${this.renderStack(defBlock.next, 1)}\n}`;
+    return `${returning}function ${baseName}(${params.join(", ")}) {\n${this.renderStack(defBlock.next, 1)}\n}`;
   }
 
   decompileTarget(target, indent = 0) {

package/src/extensions.js

@@ -165,18 +165,191 @@ export const Color = {
   hexToDecimal(hex) {
     return Color.rgbToDecimal(Color.hexToRgb(hex));
   },
+  hsvToRgb(hsv) {
+    let h = hsv.h % 360;
+    if (h < 0) h += 360;
+    const s = Math.max(0, Math.min(hsv.s, 1));
+    const v = Math.max(0, Math.min(hsv.v, 1));
+
+    const i = Math.floor(h / 60);
+    const f = h / 60 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - s * f);
+    const t = v * (1 - s * (1 - f));
+
+    let r;
+    let g;
+    let b;
+    switch (i) {
+      default:
+      case 0:
+        r = v;
+        g = t;
+        b = p;
+        break;
+      case 1:
+        r = q;
+        g = v;
+        b = p;
+        break;
+      case 2:
+        r = p;
+        g = v;
+        b = t;
+        break;
+      case 3:
+        r = p;
+        g = q;
+        b = v;
+        break;
+      case 4:
+        r = t;
+        g = p;
+        b = v;
+        break;
+      case 5:
+        r = v;
+        g = p;
+        b = q;
+        break;
+    }
+
+    return {
+      r: Math.floor(r * 255),
+      g: Math.floor(g * 255),
+      b: Math.floor(b * 255),
+    };
+  },
+  rgbToHsv(rgb) {
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    const x = Math.min(Math.min(r, g), b);
+    const v = Math.max(Math.max(r, g), b);
+
+    // For greys hue is arbitrarily reported as zero.
+    let h = 0;
+    let s = 0;
+    if (x !== v) {
+      const f = r === x ? g - b : g === x ? b - r : r - g;
+      const i = r === x ? 3 : g === x ? 5 : 1;
+      h = ((i - f / (v - x)) * 60) % 360;
+      s = (v - x) / v;
+    }
+
+    return { h: h, s: s, v: v };
+  },
+  mixRgb(rgb0, rgb1, fraction1) {
+    if (fraction1 <= 0) return rgb0;
+    if (fraction1 >= 1) return rgb1;
+    const fraction0 = 1 - fraction1;
+    return {
+      r: fraction0 * rgb0.r + fraction1 * rgb1.r,
+      g: fraction0 * rgb0.g + fraction1 * rgb1.g,
+      b: fraction0 * rgb0.b + fraction1 * rgb1.b,
+    };
+  },
 };
 
-/** `Scratch.Cast`. */
+/**
+ * `Scratch.Cast` (scratch-vm's `util/cast`, as exposed to extensions).
+ *
+ * Each member mirrors the VM's implementation, including Scratch's own
+ * coercion rules — `Cast.toBoolean("0")` is false, `Cast.compare` is
+ * case-insensitive for text and numeric otherwise.
+ */
 export const Cast = {
   toString: (value) => String(value),
   toNumber: (value) => {
+    if (typeof value === "number") return Number.isNaN(value) ? 0 : value;
     const n = Number(value);
     return Number.isNaN(n) ? 0 : n;
   },
-  toBoolean: (value) =>
-    typeof value === "boolean" ? value : String(value) === "true",
-  toList: (value) => (Array.isArray(value) ? value : [value]),
+  toBoolean: (value) => {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      // These exact strings are false in Scratch; everything else is true.
+      if (value === "" || value === "0" || value.toLowerCase() === "false")
+        return false;
+      return true;
+    }
+    return Boolean(value);
+  },
+  /** 0 when equal, negative when `a` sorts first, positive otherwise. */
+  compare: (a, b) => {
+    // Scratch does not treat "0", "\t" or strings containing them as zero.
+    const isNotActuallyZero = (value) => {
+      if (typeof value !== "string") return false;
+      for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code === 48 || code === 9) return false;
+      }
+      return true;
+    };
+    let n1 = Number(a);
+    let n2 = Number(b);
+    if (n1 === 0 && isNotActuallyZero(a)) n1 = NaN;
+    else if (n2 === 0 && isNotActuallyZero(b)) n2 = NaN;
+    if (Number.isNaN(n1) || Number.isNaN(n2)) {
+      const s1 = String(a).toLowerCase();
+      const s2 = String(b).toLowerCase();
+      if (s1 < s2) return -1;
+      if (s1 > s2) return 1;
+      return 0;
+    }
+    if (
+      (n1 === Infinity && n2 === Infinity) ||
+      (n1 === -Infinity && n2 === -Infinity)
+    )
+      return 0;
+    return n1 - n2;
+  },
+  toRgbColorList: (value) => {
+    const color = Cast.toRgbColorObject(value);
+    return [color.r, color.g, color.b];
+  },
+  toRgbColorObject: (value) => {
+    let color;
+    if (typeof value === "object") value += "";
+    if (typeof value === "string" && value.substring(0, 1) === "#") {
+      color = Color.hexToRgb(value);
+      // A string that only looks like a hex colour casts to black.
+      if (!color) color = { r: 0, g: 0, b: 0, a: 255 };
+    } else {
+      color = Color.decimalToRgb(Cast.toNumber(value));
+    }
+    return color;
+  },
+  isWhiteSpace: (value) =>
+    value === null || (typeof value === "string" && value.trim().length === 0),
+  isInt: (value) => {
+    if (typeof value === "number") {
+      if (Number.isNaN(value)) return true;
+      return value === Math.floor(value);
+    }
+    if (typeof value === "boolean") return true;
+    if (typeof value === "string") return value.indexOf(".") < 0;
+    return false;
+  },
+  get LIST_INVALID() {
+    return "INVALID";
+  },
+  get LIST_ALL() {
+    return "ALL";
+  },
+  toListIndex: (index, length, acceptAll) => {
+    if (typeof index !== "number") {
+      if (index === "all") return acceptAll ? Cast.LIST_ALL : Cast.LIST_INVALID;
+      if (index === "last") return length > 0 ? length : Cast.LIST_INVALID;
+      if (index === "random" || index === "any")
+        return length > 0
+          ? 1 + Math.floor(Math.random() * length)
+          : Cast.LIST_INVALID;
+    }
+    index = Math.floor(Cast.toNumber(index));
+    if (index < 1 || index > length) return Cast.LIST_INVALID;
+    return index;
+  },
 };
 
 // -------------------------------------------------------------- translation
@@ -184,23 +357,35 @@ export const Cast = {
 /**
  * Map a `Scratch.ArgumentType` onto a Triflare Fx input descriptor.
  * @param {object} arg
- * @returns {{type: string}}
+ * @returns {{type: string, default?: string|number}}
  */
 function argumentSpec(arg) {
   const type = arg && arg.type;
+  let spec;
   switch (type) {
     case ArgumentType.BOOLEAN:
-      return { type: "boolean" };
-    case ArgumentType.NUMBER:
-      return { type: "number" };
+      spec = { type: "boolean" };
+      break;
     case ArgumentType.ANGLE:
-      return { type: "angle" };
+      spec = { type: "angle" };
+      break;
     case ArgumentType.COLOR:
-      return { type: "color" };
-    // Matrix, note, costume, backdrop, sound and string all travel as text.
+      spec = { type: "color" };
+      break;
+    // A note is a MIDI number, so it takes numeric input like `NUMBER`.
+    case ArgumentType.NOTE:
+    case ArgumentType.NUMBER:
+      spec = { type: "number" };
+      break;
+    // Matrix, costume, sound, PM menus and plain strings all travel as text.
     default:
-      return { type: "string" };
+      spec = { type: "string" };
   }
+  // Extensions declare the value a call falls back to when it omits the arg.
+  if (arg && arg.defaultValue !== undefined && arg.defaultValue !== null) {
+    spec.default = arg.defaultValue;
+  }
+  return spec;
 }
 
 /**
@@ -270,10 +455,14 @@ function registerInfo(catalog, info, sourceName) {
       extension: id,
     };
     if (kind === "hat") {
-      entry.args = Object.entries(block.arguments || {}).map(([name, arg]) => ({
-        input: name,
-        type: argumentSpec(arg).type,
-      }));
+      entry.args = Object.entries(block.arguments || {}).map(([name, arg]) => {
+        const spec = argumentSpec(arg);
+        return {
+          input: name,
+          type: spec.type,
+          ...(spec.default !== undefined ? { default: spec.default } : {}),
+        };
+      });
     } else if (
       block.blockType === BlockType.CONDITIONAL ||
       block.blockType === BlockType.LOOP
@@ -331,15 +520,20 @@ function permissive(label) {
   return proxy;
 }
 
-function makeSandbox(registered, { unsandboxed = false } = {}) {
+export function makeSandbox(registered, { unsandboxed = false } = {}) {
+  /** A function that rejects: the sandbox has no browser or network. */
+  const unavailable = (name) => () =>
+    Promise.reject(new Error(`${name} is not available while compiling`));
   const Scratch = {
     extensions: {
       register(extension) {
         registered.push(extension);
       },
-      // PenguinMod sets `unsandboxed: true` for unsandboxed loads and exposes
-      // `isPenguinMod`, so extensions can adapt to whichever loader runs them.
-      unsandboxed: Boolean(unsandboxed),
+      // TurboWarp documents `unsandboxed` as true when unsandboxed and
+      // undefined otherwise — never false.
+      unsandboxed: unsandboxed || undefined,
+      // PenguinMod's unsandboxed loader sets this; exposing it in both modes
+      // keeps PenguinMod-only extensions loadable here.
       isPenguinMod: true,
     },
     BlockType,
@@ -351,15 +545,31 @@ function makeSandbox(registered, { unsandboxed = false } = {}) {
     Clone,
     Color,
     Cast,
-    translate: (value) => {
-      if (typeof value === "string") return value;
-      if (
-        value &&
-        typeof value === "object" &&
-        typeof value.default === "string"
-      )
-        return value.default;
-      return value == null ? "" : String(value);
+    // tw-l10n exposes `translate(message, args)`, `translate.setup({…})` and a
+    // read-only `translate.language` on the same function. Generated l10n
+    // bundles call `setup({…})` at module scope before registering.
+    translate: Object.defineProperty(
+      Object.assign(
+        (message) => {
+          if (typeof message === "string") return message;
+          if (message && typeof message === "object") {
+            return typeof message.default === "string" ? message.default : "";
+          }
+          throw new Error("unsupported data type in translate()");
+        },
+        { setup() {} },
+      ),
+      "language",
+      { get: () => "en", enumerable: true },
+    ),
+    // `Scratch.external` loads sibling resources; the sandbox has no browser,
+    // so its entries reject instead of resolving like a module.
+    external: {
+      importModule: unavailable("Scratch.external"),
+      fetch: unavailable("Scratch.external"),
+      dataURL: unavailable("Scratch.external"),
+      blob: unavailable("Scratch.external"),
+      evalAndReturn: unavailable("Scratch.external"),
     },
     canFetch: () => Promise.resolve(false),
     fetch: () =>
@@ -547,6 +757,7 @@ const BASE64_PAYLOAD = /^[A-Za-z0-9+/=\s]*$/;
  * @param {string} source
  * @returns {string}
  */
+/** Encode extension source as a self-contained JavaScript data URI. */
 export function extensionDataUri(source) {
   const base64 = Buffer.from(String(source), "utf8").toString("base64");
   return `data:text/javascript;base64,${base64}`;
@@ -572,8 +783,13 @@ export function readExtensionDataUri(uri) {
   }
 }
 
-/** Resolve a config entry to source text. */
-async function resolveSource(entry, baseDir, fetchImpl) {
+/**
+ * Resolve a config entry to source text and the original bytes.
+ *
+ * The raw buffer is retained so vendoring can lock exactly what the server
+ * returned, even when the text decoder strips a byte-order mark.
+ */
+export async function resolveSource(entry, baseDir, fetchImpl) {
   const value = String(entry);
   if (/^data:/i.test(value)) {
     const source = readExtensionDataUri(value);
@@ -581,7 +797,13 @@ async function resolveSource(entry, baseDir, fetchImpl) {
       throw new Error(
         "unsupported data URI; expected base64 or percent-encoded JavaScript",
       );
-    return { source, remote: false, dataUri: true, url: value };
+    return {
+      source,
+      buffer: Buffer.from(source, "utf8"),
+      remote: false,
+      dataUri: true,
+      url: value,
+    };
   }
   if (/^https?:\/\//i.test(value)) {
     const fetchFn = fetchImpl || globalThis.fetch;
@@ -590,13 +812,24 @@ async function resolveSource(entry, baseDir, fetchImpl) {
     const response = await fetchFn(value);
     if (!response.ok)
       throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
-    return { source: await response.text(), remote: true, url: value };
+    const buffer =
+      typeof response.arrayBuffer === "function"
+        ? Buffer.from(await response.arrayBuffer())
+        : Buffer.from(await response.text(), "utf8");
+    return {
+      source: buffer.toString("utf8").replace(/^\uFEFF/, ""),
+      buffer,
+      remote: true,
+      url: value,
+    };
   }
   const resolved = path.isAbsolute(value)
     ? value
     : path.resolve(baseDir, value);
+  const buffer = fs.readFileSync(resolved);
   return {
-    source: fs.readFileSync(resolved, "utf8"),
+    source: buffer.toString("utf8"),
+    buffer,
     remote: false,
     url: value,
     file: resolved,
@@ -640,19 +873,39 @@ async function evaluateExtensionAny(source, filename) {
   }
 }
 
+/**
+ * Inspect extension source without running it in the Node.js process.
+ * Useful to propose an extension id while vendoring or migrating.
+ * @param {string} source
+ * @param {string} [filename]
+ * @returns {Promise<{infos: object[], unsandboxed: boolean}>}
+ */
+export async function inspectExtension(source, filename = "extension") {
+  return evaluateExtensionAny(source, filename);
+}
+
 /**
  * Load a list of extension references.
  *
  * @param {Array<string>} list Paths, `http(s)://` URLs or `data:` URIs.
- * @param {{baseDir?: string, fetchImpl?: typeof fetch, expectUnsandboxed?: string|string[]}} [options]
+ * @param {{baseDir?: string, fetchImpl?: typeof fetch, expectUnsandboxed?: string|string[], reportUnmatchedUnsandboxed?: boolean}} [options]
  *   `expectUnsandboxed` acknowledges extensions that are known to require
- *   unsandboxed mode, silencing the warning for them.
- * @returns {Promise<{catalog: Record<string, object>, extensionUrls: Record<string, string>, warnings: string[], ids: string[], unsandboxed: string[]}>}
+ *   unsandboxed mode, silencing the warning for them. Set
+ *   `reportUnmatchedUnsandboxed` to false when a caller combines declarations
+ *   from several loaders and reports unmatched names itself.
+ * @returns {Promise<{catalog: Record<string, object>, extensionUrls: Record<string, string>, warnings: string[], ids: string[], unsandboxed: string[], matchedUnsandboxed: string[], unnecessaryUnsandboxed: string[]}>}
  *   `unsandboxed` holds the ids of extensions that only load unsandboxed.
+ *   `matchedUnsandboxed` and `unnecessaryUnsandboxed` let callers combine
+ *   declarations across multiple loaders without double-reporting them.
  */
 export async function loadExtensions(
   list,
-  { baseDir = process.cwd(), fetchImpl, expectUnsandboxed = [] } = {},
+  {
+    baseDir = process.cwd(),
+    fetchImpl,
+    expectUnsandboxed = [],
+    reportUnmatchedUnsandboxed = true,
+  } = {},
 ) {
   const catalog = {};
   const extensionUrls = {};
@@ -731,17 +984,27 @@ export async function loadExtensions(
         "project.unsandboxed in fx.yml once you trust it)",
     );
   }
-  for (const name of declared) {
-    if (declaredNotNeeded.has(name)) {
-      warnings.push(
-        `project.unsandboxed entry "${name}" loads in the sandbox; remove it from fx.yml`,
-      );
-    } else if (!declaredSeen.has(name)) {
-      warnings.push(
-        `project.unsandboxed entry "${name}" does not match any loaded extension`,
-      );
+  if (reportUnmatchedUnsandboxed) {
+    for (const name of declared) {
+      if (declaredNotNeeded.has(name)) {
+        warnings.push(
+          `project.unsandboxed entry "${name}" loads in the sandbox; remove it from fx.yml`,
+        );
+      } else if (!declaredSeen.has(name)) {
+        warnings.push(
+          `project.unsandboxed entry "${name}" does not match any loaded extension`,
+        );
+      }
     }
   }
 
-  return { catalog, extensionUrls, warnings, ids, unsandboxed };
+  return {
+    catalog,
+    extensionUrls,
+    warnings,
+    ids,
+    unsandboxed,
+    matchedUnsandboxed: [...declaredSeen],
+    unnecessaryUnsandboxed: [...declaredNotNeeded],
+  };
 }