Refactoring Code.gs

[mh-firouzjah]

سلام،
متاسفانه به دلیل مشکلی که در اتصالم به گیتهاب دارم امکان فورک کردن و PR مقدور نبود.
من کد جاوا اسکریپت مربوط به GAS node رو ابتدا به تایپ اسکریپت و سپس مجددا به جاوا اسکریپت بازنویسی کردم و یکی دو مورد مشکل جزئی رو برطرف کردم و همین طور مشکلی که در ریلیز ۱.۹.۲۸ وجود داشت ولی متاسفانه فیکس نشد بلکه کلا اون روش کنار گذاشته شد رو هم حل کردم.
ضمن اینکه من مدتی از آپشن کش کردن کردن در شیت استفاده کردم و متوجه شدم این روش باعث بروز اشکالاتی میشه که بعضی درخواستها به تایم اوت میخورن و همین طور استفاده از شیت باعث مصرف شدن quota هم میشه. پس در این بازنویسی اون قسمت رو حذف کردم.
منتهی درصورتی که فکر می‌کنید وجود سیستم کش میتونه مفید باشه میشه از آپشن داخلی اپ اسکریپت که دیگه quota هم نمی‌سوزونه استفاده کنیم که یک بخش ناقص برای نمایش اون هم آخر فایلها نگهداشتم.
در هر صورت از نظر هوش مصنوعی باتوجه به فیلترینگ خاصی که در پروسه کش کردن لحاظ کرده بودین ظاهرا استفاده از کش چندان سود زیادی نداره ولی این از سطح اطلاعات شخصی من خارج هست.
نکته‌ی دیگه اینکه بجای نوشتن AUTH_KEY به صورت مستقیم در کد اون رو به بخش پراپرتی‌های اسکریپت منتقل کردم تا در صورتی که کسی بخواد کد خودش رو به اشتراک بذاره سهوا اون اطلاعات رو نفرسته.
با استفاده از ابزار clasp میشه کد تایپ اسکریپت رو به صورت اتوماتیک از سیستم خودمون پوش کنیم روی GAS و تبدیل به جاوااسکریپت رو خودش انجام میده ولی متاسفانه این مورد هم به خاطر کانکشن بسیار ناپایدار اینترنتم برای من مقدور نبوده.
همین طور امکان ارسال کدها به صورت فایل رو نداشتم و بالجبار به صورتی متنی در ادامه این پست قرار دادم.
در استفاده‌ی آزمایشی که داشتم مشکل خاصی مشاهده نشده امیدورام بررسی بیشتری روش صورت بگیره.
سپاس از توجه شما

[mh-firouzjah]

/**
 * DomainFront Relay — Google Apps Script
 *
 * TWO modes:
* 1. Single: POST { k, m, u, h, b, ct, r } → { s, h, b }
* 2. Batch: POST { k, q: [{m,u,h,b,ct,r}, ...] } → { q: [{s,h,b}, ...] }
* Uses UrlFetchApp.fetchAll() — all URLs fetched IN PARALLEL.
 *
 * DEPLOYMENT:
* 1. Go to https://script.google.com → New project
* 2. Delete the default code, paste THIS entire file
* 3. Go project settings (⚙️) → Script Properties → Add script property → property: AUTH_KEY, value: Your secret key
* 4. Click Deploy → New deployment
* 5. Type: Web app | Execute as: Me | Who has access: Anyone
* 6. Copy the Deployment ID into config.toml (previous config.json) as "script_id"
 *
 */
const PROPERTIES = PropertiesService.getScriptProperties();

const AUTH_KEY = PROPERTIES.getProperty("AUTH_KEY");
// Active-probing defense. When false (production default), bad AUTH_KEY
// requests get a decoy HTML page that looks like a placeholder Apps
// Script web app instead of the JSON `{"e":"unauthorized"}` body. This
// makes the deployment indistinguishable from a forgotten-but-public
// Apps Script project to active scanners that POST malformed payloads
// looking for proxy endpoints.
//
// Set to `true` during initial setup if a misconfigured client is
// hitting "unauthorized" and you want the explicit JSON error to debug
// — then flip back to false before the deployment is widely shared.
// (Inspired by #365 Section 3, mhrv-rs v1.8.0+.)
const DIAGNOSTIC_MODE = false;

// Connection-level + IP-leak request headers we strip before forwarding
// to the destination. Browser capability headers (sec-ch-ua*, sec-fetch-*)
// stay intact — modern apps like Google Meet use them for browser gating.
// We also drop the `X-Forwarded-*` / `Forwarded` / `Via` family so a
// misconfigured upstream proxy on the user side can't leak the user's
// real IP through the relay path. Mirrors upstream
// `masterking32/MasterHttpRelayVPN@3094288`.
const SKIP_HEADERS = new Set(
  "host", "connection", "content-length",
  "transfer-encoding", "proxy-connection", "proxy-authorization",
  "priority", "te",
  "x-forwarded-for", "x-forwarded-host", "x-forwarded-proto",
  "x-forwarded-port", "x-real-ip", "forwarded", "via",
);

// Methods we consider safe to replay if `UrlFetchApp.fetchAll()` raises.
// GET/HEAD/OPTIONS are idempotent per RFC 9110; POST/PUT/PATCH/DELETE
// can have side-effects so we surface the error instead of silently
// re-firing them.
const SAFE_REPLAY_METHODS = new Set("GET", "HEAD", "OPTIONS");
const URL_PATTERN = /^https?:\/\//i;
// Headers that disqualify a request from the cache path.
const CACHE_BUSTING_HEADERS = new Set(
  "authorization", "cookie", "x-api-key",
  "proxy-authorization", "set-cookie",
);

// HTML body for the bad-auth decoy. Mimics a minimal Apps Script-style
// placeholder page — no proxy-shaped JSON, nothing distinctive enough
// for a probe to fingerprint as a tunnel endpoint.
const DECOY_HTML =
  '<!DOCTYPE html><html><head><title>Web App</title></head>' +
  '<body><p>The script completed but did not return anything.</p>' +
  '</body></html>';

/**
 * @typedef {Object} ClientRequest
 * @property {GoogleAppsScript.URL_Fetch.HttpMethod} m
 * @property {string} u - URL to relay
 * @property {GoogleAppsScript.URL_Fetch.HttpHeaders} h
 * @property {string} b  - Request body
 * @property {string} ct - Request contentType
 * @property {boolean} r - Request goes through exit node
 */

/**
 * @typedef {Object} ClientRequestSingle
 * @property {string} k - Auth token
 * @property {GoogleAppsScript.URL_Fetch.HttpMethod} m
 * @property {string} u - URL to relay
 * @property {GoogleAppsScript.URL_Fetch.HttpHeaders} h
 * @property {string} b  - Request body
 * @property {string} ct - Request contentType
 * @property {boolean} r - Request goes through exit node
 */

/**
 * @typedef {Object} ClientRequestBatch
 * @property {string} k
 * @property {Array<ClientRequest>} q
 */

/**
 * @typedef RelayErrorResponse
 * @property {string} e
 */

/**
 * @typedef RelaySingleResponse
 * @property {number} s
 * @property {GoogleAppsScript.URL_Fetch.HttpHeaders} h
 * @property {string} b
*/

/**
 * @typedef RelayBatchResponse
 * @property {Array<RelaySingleResponse | RelayErrorResponse>} q
 */

/** @param {RelayErrorResponse | RelaySingleResponse | RelayBatchResponse} obj  */
function _relayResponse (obj) {
  return ContentService.createTextOutput(JSON.stringify(obj)).setMimeType(
    ContentService.MimeType.JSON
  );
}

/**
 * `doGet` is what active scanners hit first (HTTP GET probes are cheaper
 * than POSTs). Apps Script defaults to a "Script function not found" page
 * here which is a fine-enough decoy on its own, but explicitly returning
 * the same harmless placeholder makes the response identical to the
 * bad-auth POST decoy — one less fingerprint vector.
 * @param {GoogleAppsScript.Events.DoGet} e
*/
function doGet (e) {
  return ContentService
    .createTextOutput(DECOY_HTML)
    .setMimeType(ContentService.MimeType.XML);
}

/** @param {RelayErrorResponse} err  */
function _decoyOrError (err) {
  if (DIAGNOSTIC_MODE) return _relayResponse(err);
  return ContentService
    .createTextOutput(DECOY_HTML)
    .setMimeType(ContentService.MimeType.XML);
}

/** @param {GoogleAppsScript.URL_Fetch.HTTPResponse} resp  */
function _respHeaders (resp) {
  return resp.getAllHeaders?.() ?? resp.getHeaders();
}

/** @param {ClientRequest} req  */
function _buildOpts (req) {
  /** @type {GoogleAppsScript.URL_Fetch.URLFetchRequestOptions} */
  let opts = {
    /** @type {GoogleAppsScript.URL_Fetch.HttpMethod} */
    method: ((req.m || "GET").toUpperCase()),
    muteHttpExceptions: true,
    followRedirects: true,          // ← always true; r flag now has different meaning
    validateHttpsCertificates: true,
    escaping: false,
  };

  if (req.h && typeof req.h === "object") {
    opts.headers = Object.fromEntries(
      Object.entries(req.h).filter(([ k ]) => !SKIP_HEADERS.has(k.toLowerCase())));
  }
  if (req.b) {
    opts.payload = Utilities.base64Decode(req.b);
    if (req.ct) opts.contentType = req.ct;
  }
  return opts;
}

/**
 * @param {GoogleAppsScript.URL_Fetch.HTTPResponse} resp
 * @return {RelaySingleResponse}
*/
function _buildResponse (resp) {
  return {
    s: resp.getResponseCode(),
    h: _respHeaders(resp),
    b: Utilities.base64Encode(resp.getContent()),
  };
}

/**
 * @param {ClientRequestSingle} req
 * @return {GoogleAppsScript.Content.TextOutput}
*/
function _doSingle (req) {
  if (!URL_PATTERN.test(req.u)) {
    return _relayResponse({ e: "bad url" });
  }


  // ── Normal relay (cache disabled or unavailable) ────────
  // Wrap the fetch + body encode in try/catch so any failure surfaces as
  // a JSON error envelope the Rust client can parse. Without this, throws
  // from UrlFetchApp.fetch (URL too long, payload too large, quota
  // exhausted, 6-minute execution timeout) or from base64Encode (response
  // body near Apps Script's ~50 MB ceiling can blow the V8 heap during
  // encode) propagate unhandled, and Apps Script serves its default
  // `<title>Web App</title>` HTML error page — which the client then
  // reports as "Relay failed: bad response: no json in: <title>Web App>..."
  // and the user has no signal as to the actual cause. Mirrors the
  // per-item try/catch in _doBatch below.
  try {
    let opts = _buildOpts(req);
    let resp = UrlFetchApp.fetch(req.u, opts);

    // Raw-return mode for exit-node path.
    // r:true = return destination body verbatim so Rust gets {s,h,b} unwrapped.
    if (req.r === true) {
      try {
        let respContent = resp.getContentText();
        /** @type {Object} */
        let respObj = JSON.parse(respContent);
        if ([ "s", "h", "b" ].every(prop => respObj.hasOwnProperty(prop)))
          return ContentService
            .createTextOutput(respContent)
            .setMimeType(ContentService.MimeType.JSON);
      } catch {
        // Resp is not comming from an exit-node, continue as before
      }
    }

    return _relayResponse(_buildResponse(resp));
  } catch (err) {
    return _relayResponse({ e: "fetch failed: " + String(err) });
  }
}

/**
 * @param {Array<ClientRequest>} items
 * @returns {GoogleAppsScript.Content.TextOutput}
*/
function _doBatch (items) {
  /** @type {Array<GoogleAppsScript.URL_Fetch.URLFetchRequest>} */
  let fetchItems = [];
  /** @type {Array<number>} */
  let fetchIndices = [];
  /** @type { Array<string>} */
  let fetchMethods = [];
  /** @type {Map<number, string>} */
  let errorMap = new Map();

  for (let i = 0; i < items.length; i++) {
    let item = items[ i ];
    if (!item || typeof item !== "object") {
      errorMap.set(i, "bad item");
      continue;
    }
    if (!URL_PATTERN.test(item.u)) {
      errorMap.set(i, "bad url");
      continue;
    }
    try {
      fetchItems.push({ url: item.u, ..._buildOpts(item) });
      fetchIndices.push(i);
      fetchMethods.push((item.m || "GET").toUpperCase());
    } catch (buildErr) {
      errorMap.set(i, String(buildErr));
    }
  }

  // fetchAll() processes all requests in parallel inside Google. If it
  // throws as a whole (e.g. one URL violates UrlFetchApp limits and
  // poisons the whole batch), degrade to per-item fetch on safe methods
  // so a single bad request does not zero out every response in the
  // batch. Mirrors upstream `masterking32/MasterHttpRelayVPN@3094288`.
  /** @type {Array<GoogleAppsScript.URL_Fetch.HTTPResponse | null>} **/
  let responses = [];
  try {
    // Single - chunk fast path; avoids the fetchAll overhead for the common case.
    if (fetchItems.length === 1) {
      responses = [ UrlFetchApp.fetch(fetchItems[ 0 ].url, fetchItems[ 0 ]) ];
    } else {
      responses = UrlFetchApp.fetchAll(fetchItems);
    }
  } catch (fetchAllErr) {
    responses = [];
    for (let j = 0; j < fetchItems.length; j++) {
      try {
        if (!SAFE_REPLAY_METHODS.has(fetchMethods[ j ])) {
          errorMap.set(fetchIndices[ j ], "batch fetchAll failed; unsafe method not replayed");
          responses[ j ] = null;
          continue;
        }
        let fallbackReq = fetchItems[ j ];
        responses[ j ] = UrlFetchApp.fetch(fallbackReq.url, fallbackReq);
      } catch (singleErr) {
        errorMap.set(fetchIndices[ j ], String(singleErr));
        responses[ j ] = null;
      }
    }
  }

  /** @type {Array<RelaySingleResponse | RelayErrorResponse>} **/
  let results = [];
  for (let i = 0; i < items.length; i++) {
    if (errorMap.has(i)) {
      results.push({ e: String(errorMap.get(i)) });
    } else {
      const fetchPos = fetchIndices.indexOf(i);
      if (fetchPos === -1 || !responses[ fetchPos ]) {
        results.push({ e: "fetch failed" });
      } else {
        results.push(_buildResponse(responses[ fetchPos ]));
      }
    }
  }
  return _relayResponse({ q: results });
}

/** @param {GoogleAppsScript.Events.DoPost} e */
function doPost (e) {
  if (!AUTH_KEY) {
    _decoyOrError({ e: "AUTH_KEY not configured" });
  }
  try {
    /** @type {ClientRequestSingle | ClientRequestBatch} **/
    let req = JSON.parse(e.postData.contents);
    if (req.k !== AUTH_KEY) return _decoyOrError({ e: "unauthorized" });

    // Batch mode: { k, q: [...] }
    if ("q" in req) {
      if (req.q.length === 0) return _relayResponse({ q: [] });
      return _doBatch(req.q);
    }
    // Single mode: { k, m, u, h, b, ct, r }
    return _doSingle(req);
  } catch (err) {
    // Parse failures of the request body are also probe-shaped — a real
    // mhrv-rs client never sends invalid JSON. Decoy for the same reason.
    return _decoyOrError({ e: String(err) });
  }
}

// Not Implemented Caching
const CACHE = CacheService.getScriptCache();
/** @param {ClientRequestSingle} req */
function _doSingleWithCache (req) {
  const cacheKey = `relay:${ req.u }`;
  const cached = CACHE.get(cacheKey);

  if (cached) return _relayResponse(JSON.parse(cached));

  // Cache miss → fetch
  const resp = _doSingle(req);
  if (resp.getMimeType() === ContentService.MimeType.JSON) {
    let respContent = resp.getContent();
    const parsed = JSON.parse(respContent);

    if (parsed.s === 200) {
      CACHE.put(cacheKey, respContent, 3600); // 1 hour
    }
  }
  return resp;
}
// End

[mh-firouzjah]

/**
 * DomainFront Relay — Google Apps Script
 *
 * TWO modes:
* 1. Single: POST { k, m, u, h, b, ct, r } → { s, h, b }
* 2. Batch: POST { k, q: [{m,u,h,b,ct,r}, ...] } → { q: [{s,h,b}, ...] }
* Uses UrlFetchApp.fetchAll() — all URLs fetched IN PARALLEL.
*/

const DIAGNOSTIC_MODE: boolean = false;
const PROPERTIES = PropertiesService.getScriptProperties();
const AUTH_KEY = PROPERTIES.getProperty("AUTH_KEY");
const URL_PATTERN = /^https?:\/\//i;
const SAFE_REPLAY_METHODS: Set<string> = new Set([ "GET", "HEAD", "OPTIONS" ]);
const SKIP_HEADERS: Set<string> = new Set([
  "host", "connection", "content-length", "priority", "te", "forwarded", "via",
  "x-forwarded-port", "x-forwarded-for", "x-forwarded-host", "x-forwarded-proto",
  "x-real-ip", "transfer-encoding", "proxy-connection", "proxy-authorization",
]);
const DECOY_HTML: string =
  '<!DOCTYPE html><html><head><title>Web App</title></head>' +
  '<body><p>The script completed but did not return anything.</p>' +
  '</body></html>';

interface ClientRequest {
  m: GoogleAppsScript.URL_Fetch.HttpMethod;
  u: string;
  h: GoogleAppsScript.URL_Fetch.HttpHeaders;
  b: string;
  ct: string;
  r: boolean;
}
interface ClientRequestSingle extends ClientRequest {
  k: string;
}
interface ClientRequestBatch {
  k: string;
  q: Array<ClientRequest>;
}
interface RelayErrorResponse {
  e: string;
}
interface RelaySingleResponse {
  s: number;
  h: GoogleAppsScript.URL_Fetch.HttpHeaders;
  b: string;
}
interface RelayBatchResponse {
  q: Array<RelaySingleResponse | RelayErrorResponse>;
}

function _relayResponse(obj: RelayErrorResponse | RelaySingleResponse | RelayBatchResponse) {
  return ContentService.createTextOutput(JSON.stringify(obj)).setMimeType(
    ContentService.MimeType.JSON
  );
}

function doGet(e: GoogleAppsScript.Events.DoGet) {
  return ContentService
    .createTextOutput(DECOY_HTML)
    .setMimeType(ContentService.MimeType.XML);
}

function _decoyOrError(err: RelayErrorResponse) {
  if (DIAGNOSTIC_MODE) return _relayResponse(err);
  return ContentService
    .createTextOutput(DECOY_HTML)
    .setMimeType(ContentService.MimeType.XML);
}

function _respHeaders(resp: GoogleAppsScript.URL_Fetch.HTTPResponse) {
  return resp.getAllHeaders?.() ?? resp.getHeaders();
}

function _buildOpts(req: ClientRequest) {
  let opts: GoogleAppsScript.URL_Fetch.URLFetchRequestOptions = {
    method: ((req.m || "GET").toUpperCase()) as GoogleAppsScript.URL_Fetch.HttpMethod,
    muteHttpExceptions: true,
    followRedirects: true,          // ← always true; r flag now has different meaning
    validateHttpsCertificates: true,
    escaping: false,
  };

  if (req.h && typeof req.h === "object") {
    opts.headers = Object.fromEntries(
      Object.entries(req.h).filter(([ k ]) => !SKIP_HEADERS.has(k.toLowerCase())));
  }
  if (req.b) {
    opts.payload = Utilities.base64Decode(req.b);
    if (req.ct) opts.contentType = req.ct;
  }
  return opts;
}

function _buildResponse(resp: GoogleAppsScript.URL_Fetch.HTTPResponse): RelaySingleResponse {
  return {
    s: resp.getResponseCode(),
    h: _respHeaders(resp) as GoogleAppsScript.URL_Fetch.HttpHeaders,
    b: Utilities.base64Encode(resp.getContent()),
  };
}

function _doSingle(req: ClientRequestSingle) {
  if (!URL_PATTERN.test(req.u)) {
    return _relayResponse({ e: "bad url" });
  }


  try {
    let opts = _buildOpts(req);
    let resp = UrlFetchApp.fetch(req.u, opts);

    // Raw-return mode for exit-node path.
    // r:true = return destination body verbatim so Rust gets {s,h,b} unwrapped.
    if (req.r === true) {
      try {
        let respContent = resp.getContentText();
        let respObj: Object = JSON.parse(respContent);
        if ([ "s", "h", "b" ].every(prop => respObj.hasOwnProperty(prop)))
          return ContentService
            .createTextOutput(respContent)
            .setMimeType(ContentService.MimeType.JSON);
      } catch {
        // Resp is not comming from an exit-node, continue as before
      }
    }

    return _relayResponse(_buildResponse(resp));
  } catch (err) {
    return _relayResponse({ e: "fetch failed: " + String(err) });
  }
}

function _doBatch(items: Array<ClientRequest>) {
  let fetchItems: Array<GoogleAppsScript.URL_Fetch.URLFetchRequest> = [];
  let fetchIndices: Array<number> = [];
  let fetchMethods: Array<string> = [];
  let errorMap: Map<number, string> = new Map();

  for (let i = 0; i < items.length; i++) {
    let item = items[ i ];
    if (!item || typeof item !== "object") {
      errorMap.set(i, "bad item");
      continue;
    }
    if (!URL_PATTERN.test(item.u)) {
      errorMap.set(i, "bad url");
      continue;
    }
    try {
      fetchItems.push({ url: item.u, ..._buildOpts(item) });
      fetchIndices.push(i);
      fetchMethods.push((item.m || "GET").toUpperCase());
    } catch (buildErr) {
      errorMap.set(i, String(buildErr));
    }
  }

  // fetchAll() processes all requests in parallel inside Google. If it
  // throws as a whole (e.g. one URL violates UrlFetchApp limits and
  // poisons the whole batch), degrade to per-item fetch on safe methods
  // so a single bad request does not zero out every response in the
  // batch. Mirrors upstream `masterking32/MasterHttpRelayVPN@3094288`.
  let responses: Array<GoogleAppsScript.URL_Fetch.HTTPResponse | null> = [];
  try {
    // Single - chunk fast path; avoids the fetchAll overhead for the common case.
    if (fetchItems.length === 1) {
      responses = [ UrlFetchApp.fetch(fetchItems[ 0 ].url, fetchItems[ 0 ]) ];
    } else {
      responses = UrlFetchApp.fetchAll(fetchItems);
    }
  } catch (fetchAllErr) {
    responses = [];
    for (let j = 0; j < fetchItems.length; j++) {
      try {
        if (!SAFE_REPLAY_METHODS.has(fetchMethods[ j ])) {
          errorMap.set(fetchIndices[ j ], "batch fetchAll failed; unsafe method not replayed");
          responses[ j ] = null;
          continue;
        }
        let fallbackReq = fetchItems[ j ];
        responses[ j ] = UrlFetchApp.fetch(fallbackReq.url, fallbackReq);
      } catch (singleErr) {
        errorMap.set(fetchIndices[ j ], String(singleErr));
        responses[ j ] = null;
      }
    }
  }

  let results: Array<RelaySingleResponse | RelayErrorResponse> = [];
  for (let i = 0; i < items.length; i++) {
    if (errorMap.has(i)) {
      results.push({ e: String(errorMap.get(i)) });
    } else {
      const fetchPos = fetchIndices.indexOf(i);
      if (fetchPos === -1 || !responses[ fetchPos ]) {
        results.push({ e: "fetch failed" });
      } else {
        results.push(_buildResponse(responses[ fetchPos ]));
      }
    }
  }
  return _relayResponse({ q: results });
}

function doPost(e: GoogleAppsScript.Events.DoPost) {
  if (!AUTH_KEY) {
    _decoyOrError({ e: "AUTH_KEY not configured" });
  }
  try {
    let req: ClientRequestSingle | ClientRequestBatch = JSON.parse(e.postData.contents);
    if (req.k !== AUTH_KEY) return _decoyOrError({ e: "unauthorized" });

    if ("q" in req) {
      if (req.q.length === 0) return _relayResponse({ q: [] });
      return _doBatch(req.q);
    }
    return _doSingle(req);
  } catch (err) {
    // Parse failures of the request body are also probe-shaped — a real
    // mhrv-rs client never sends invalid JSON. Decoy for the same reason.
    return _decoyOrError({ e: String(err) });
  }
}

// Not Implemented Caching
const CACHE = CacheService.getScriptCache();
function _doSingleWithCache(req: ClientRequestSingle) {
  const cacheKey = `relay:${ req.u }`;
  const cached = CACHE.get(cacheKey);

  if (cached) return _relayResponse(JSON.parse(cached));

  // Cache miss → fetch
  const resp = _doSingle(req);
  if (resp.getMimeType() === ContentService.MimeType.JSON) {
    let respContent = resp.getContent();
    const parsed = JSON.parse(respContent);

    if (parsed.s === 200) {
      CACHE.put(cacheKey, respContent, 3600); // 1 hour
    }
  }
  return resp;
}
// End