@konomi-app/kintone-utilities 5.17.1 → 6.0.1

package/dist/index.cjs

@@ -0,0 +1,2076 @@
+'use strict';
+
+// src/character-hebon.ts
+var hebonMap = {
+  \u3042: "A",
+  \u3044: "I",
+  \u3046: "U",
+  \u3048: "E",
+  \u304A: "O",
+  \u304B: "KA",
+  \u304D: "KI",
+  \u304F: "KU",
+  \u3051: "KE",
+  \u3053: "KO",
+  \u3055: "SA",
+  \u3057: "SHI",
+  \u3059: "SU",
+  \u305B: "SE",
+  \u305D: "SO",
+  \u305F: "TA",
+  \u3061: "CHI",
+  \u3064: "TSU",
+  \u3066: "TE",
+  \u3068: "TO",
+  \u306A: "NA",
+  \u306B: "NI",
+  \u306C: "NU",
+  \u306D: "NE",
+  \u306E: "NO",
+  \u306F: "HA",
+  \u3072: "HI",
+  \u3075: "FU",
+  \u3078: "HE",
+  \u307B: "HO",
+  \u307E: "MA",
+  \u307F: "MI",
+  \u3080: "MU",
+  \u3081: "ME",
+  \u3082: "MO",
+  \u3084: "YA",
+  \u3086: "YU",
+  \u3088: "YO",
+  \u3089: "RA",
+  \u308A: "RI",
+  \u308B: "RU",
+  \u308C: "RE",
+  \u308D: "RO",
+  \u308F: "WA",
+  \u3090: "I",
+  \u3091: "E",
+  \u3092: "O",
+  \u3041: "A",
+  \u3043: "I",
+  \u3045: "U",
+  \u3047: "E",
+  \u3049: "O",
+  \u304C: "GA",
+  \u304E: "GI",
+  \u3050: "GU",
+  \u3052: "GE",
+  \u3054: "GO",
+  \u3056: "ZA",
+  \u3058: "JI",
+  \u305A: "ZU",
+  \u305C: "ZE",
+  \u305E: "ZO",
+  \u3060: "DA",
+  \u3062: "JI",
+  \u3065: "ZU",
+  \u3067: "DE",
+  \u3069: "DO",
+  \u3070: "BA",
+  \u3073: "BI",
+  \u3076: "BU",
+  \u3079: "BE",
+  \u307C: "BO",
+  \u3071: "PA",
+  \u3074: "PI",
+  \u3077: "PU",
+  \u307A: "PE",
+  \u307D: "PO",
+  \u304D\u3083: "KYA",
+  \u304D\u3085: "KYU",
+  \u304D\u3087: "KYO",
+  \u3057\u3083: "SHA",
+  \u3057\u3085: "SHU",
+  \u3057\u3087: "SHO",
+  \u3061\u3083: "CHA",
+  \u3061\u3085: "CHU",
+  \u3061\u3087: "CHO",
+  \u3061\u3047: "CHE",
+  \u306B\u3083: "NYA",
+  \u306B\u3085: "NYU",
+  \u306B\u3087: "NYO",
+  \u3072\u3083: "HYA",
+  \u3072\u3085: "HYU",
+  \u3072\u3087: "HYO",
+  \u307F\u3083: "MYA",
+  \u307F\u3085: "MYU",
+  \u307F\u3087: "MYO",
+  \u308A\u3083: "RYA",
+  \u308A\u3085: "RYU",
+  \u308A\u3087: "RYO",
+  \u304E\u3083: "GYA",
+  \u304E\u3085: "GYU",
+  \u304E\u3087: "GYO",
+  \u3058\u3083: "JA",
+  \u3058\u3085: "JU",
+  \u3058\u3087: "JO",
+  \u3073\u3083: "BYA",
+  \u3073\u3085: "BYU",
+  \u3073\u3087: "BYO",
+  \u3074\u3083: "PYA",
+  \u3074\u3085: "PYU",
+  \u3074\u3087: "PYO"
+};
+var aaSet = {
+  AA: true,
+  EE: true,
+  II: false,
+  // I は連続しても省略しない
+  OO: true,
+  OU: true,
+  UU: true
+};
+var getHebon = (s, index) => {
+  let h = null;
+  let c = null;
+  if (index + 1 < s.length) {
+    c = s.substring(index, index + 2);
+    h = hebonMap[c];
+  }
+  if (!h && index < s.length) {
+    c = s.substring(index, index + 1);
+    h = hebonMap[c];
+  }
+  return { c: c ?? "", h: h ?? null };
+};
+function toHebon(s) {
+  let hebon = "";
+  let lastHebon = "";
+  let i = 0;
+  while (i < s.length) {
+    const hr = getHebon(s, i);
+    if (hr.c === "\u3063") {
+      const nextHr = getHebon(s, i + 1);
+      if (nextHr.h !== null) {
+        if (nextHr.h.startsWith("CH")) {
+          hr.h = "T";
+        } else {
+          hr.h = nextHr.h.substring(0, 1);
+        }
+      }
+    } else if (hr.c === "\u3093") {
+      const nextHr = getHebon(s, i + 1);
+      if (nextHr.h !== null && "BMP".indexOf(nextHr.h.charAt(0)) !== -1) {
+        hr.h = "M";
+      } else {
+        hr.h = "N";
+      }
+    } else if (hr.c === "\u30FC") {
+      hr.h = "";
+    }
+    if (hr.h !== null) {
+      if (lastHebon !== null) {
+        let htest = lastHebon + hr.h;
+        if (htest.length > 2) {
+          htest = htest.substring(htest.length - 2);
+        }
+        if (aaSet[htest]) {
+          hr.h = "";
+        }
+      }
+      hebon += hr.h;
+    } else {
+      hebon += hr.c;
+    }
+    lastHebon = hr.h;
+    i += hr.c.length;
+  }
+  return hebon;
+}
+
+// src/character-width-conversion.ts
+var convertKatakanaToHiragana = (target) => {
+  return target.replace(
+    /[\u30a1-\u30f6]/g,
+    (match) => String.fromCharCode(match.charCodeAt(0) - 96)
+  );
+};
+var convertFullwidthAlphanumericToHalfwidth = (target) => {
+  return target.replace(/[Ａ-Ｚａ-ｚ０-９]/g, (s) => String.fromCharCode(s.charCodeAt(0) - 65248));
+};
+var convertHalfwidthKatakanaToFullwidth = (target) => {
+  const KANA_CONVERTION_MAP = {
+    \uFF76\uFF9E: "\u30AC",
+    \uFF77\uFF9E: "\u30AE",
+    \uFF78\uFF9E: "\u30B0",
+    \uFF79\uFF9E: "\u30B2",
+    \uFF7A\uFF9E: "\u30B4",
+    \uFF7B\uFF9E: "\u30B6",
+    \uFF7C\uFF9E: "\u30B8",
+    \uFF7D\uFF9E: "\u30BA",
+    \uFF7E\uFF9E: "\u30BC",
+    \uFF7F\uFF9E: "\u30BE",
+    \uFF80\uFF9E: "\u30C0",
+    \uFF81\uFF9E: "\u30C2",
+    \uFF82\uFF9E: "\u30C5",
+    \uFF83\uFF9E: "\u30C7",
+    \uFF84\uFF9E: "\u30C9",
+    \uFF8A\uFF9E: "\u30D0",
+    \uFF8B\uFF9E: "\u30D3",
+    \uFF8C\uFF9E: "\u30D6",
+    \uFF8D\uFF9E: "\u30D9",
+    \uFF8E\uFF9E: "\u30DC",
+    \uFF8A\uFF9F: "\u30D1",
+    \uFF8B\uFF9F: "\u30D4",
+    \uFF8C\uFF9F: "\u30D7",
+    \uFF8D\uFF9F: "\u30DA",
+    \uFF8E\uFF9F: "\u30DD",
+    \uFF73\uFF9E: "\u30F4",
+    \uFF9C\uFF9E: "\u30F7",
+    \uFF66\uFF9E: "\u30FA",
+    \uFF71: "\u30A2",
+    \uFF72: "\u30A4",
+    \uFF73: "\u30A6",
+    \uFF74: "\u30A8",
+    \uFF75: "\u30AA",
+    \uFF76: "\u30AB",
+    \uFF77: "\u30AD",
+    \uFF78: "\u30AF",
+    \uFF79: "\u30B1",
+    \uFF7A: "\u30B3",
+    \uFF7B: "\u30B5",
+    \uFF7C: "\u30B7",
+    \uFF7D: "\u30B9",
+    \uFF7E: "\u30BB",
+    \uFF7F: "\u30BD",
+    \uFF80: "\u30BF",
+    \uFF81: "\u30C1",
+    \uFF82: "\u30C4",
+    \uFF83: "\u30C6",
+    \uFF84: "\u30C8",
+    \uFF85: "\u30CA",
+    \uFF86: "\u30CB",
+    \uFF87: "\u30CC",
+    \uFF88: "\u30CD",
+    \uFF89: "\u30CE",
+    \uFF8A: "\u30CF",
+    \uFF8B: "\u30D2",
+    \uFF8C: "\u30D5",
+    \uFF8D: "\u30D8",
+    \uFF8E: "\u30DB",
+    \uFF8F: "\u30DE",
+    \uFF90: "\u30DF",
+    \uFF91: "\u30E0",
+    \uFF92: "\u30E1",
+    \uFF93: "\u30E2",
+    \uFF94: "\u30E4",
+    \uFF95: "\u30E6",
+    \uFF96: "\u30E8",
+    \uFF97: "\u30E9",
+    \uFF98: "\u30EA",
+    \uFF99: "\u30EB",
+    \uFF9A: "\u30EC",
+    \uFF9B: "\u30ED",
+    \uFF9C: "\u30EF",
+    \uFF66: "\u30F2",
+    \uFF9D: "\u30F3",
+    \uFF67: "\u30A1",
+    \uFF68: "\u30A3",
+    \uFF69: "\u30A5",
+    \uFF6A: "\u30A7",
+    \uFF6B: "\u30A9",
+    \uFF6F: "\u30C3",
+    \uFF6C: "\u30E3",
+    \uFF6D: "\u30E5",
+    \uFF6E: "\u30E7",
+    "\uFF61": "\u3002",
+    "\uFF64": "\u3001",
+    \uFF70: "\u30FC",
+    "\uFF62": "\u300C",
+    "\uFF63": "\u300D",
+    "\uFF65": "\u30FB"
+  };
+  const regexp = new RegExp(`(${Object.keys(KANA_CONVERTION_MAP).join("|")})`, "g");
+  return target.replace(regexp, (s) => KANA_CONVERTION_MAP[s]).replace(/ﾞ/g, "\u309B").replace(/ﾟ/g, "\u309C");
+};
+var getYuruChara = (target, options) => {
+  const {
+    isZenkakuEisujiSensitive = false,
+    isCaseSensitive = false,
+    isHankakuKatakanaSensitive = false,
+    isKatakanaSensitive = false,
+    isHebonSensitive = false,
+    isHyphenSensitive = false
+  } = options || {};
+  let converted = target;
+  if (!isZenkakuEisujiSensitive) {
+    converted = convertFullwidthAlphanumericToHalfwidth(converted);
+  }
+  if (!isHankakuKatakanaSensitive) {
+    converted = convertHalfwidthKatakanaToFullwidth(converted);
+  }
+  if (!isKatakanaSensitive) {
+    converted = convertKatakanaToHiragana(converted);
+  }
+  if (!isHebonSensitive) {
+    converted = toHebon(converted);
+  }
+  if (!isCaseSensitive) {
+    converted = converted.toLowerCase();
+  }
+  if (!isHyphenSensitive) {
+    converted = converted.replace(
+      /[\u002D\u2010-\u2015\u2212\u301C\u30FC\uFF0D\u005F\uFF3F\uFF5E]+/g,
+      "-"
+    );
+  }
+  return converted;
+};
+
+// src/cybozu.ts
+var getSchema = () => cybozu?.data?.page?.SCHEMA_DATA || cybozu?.data?.page?.FORM_DATA?.schema || null;
+var getMetaTable_UNSTABLE = () => {
+  const schema = getSchema();
+  const fieldList = schema?.table?.fieldList;
+  if (!fieldList) {
+    return null;
+  }
+  return Object.values(fieldList);
+};
+var getMetaSubtable_UNSTABLE = () => {
+  const schema = getSchema();
+  const subtable = schema?.subTable;
+  if (!subtable) {
+    return null;
+  }
+  const subtableList = Object.values(subtable);
+  return subtableList;
+};
+var getMetaFields_UNSTABLE = () => {
+  return [...getMetaTable_UNSTABLE() || [], ...getMetaSubtable_UNSTABLE() || []];
+};
+var getMetaFieldId_UNSTABLE = (code) => {
+  const fields = getMetaFields_UNSTABLE();
+  if (!fields) {
+    return null;
+  }
+  for (const field2 of fields) {
+    if (field2?.var === code) {
+      return field2?.id || null;
+    }
+  }
+  return null;
+};
+var getMetaSubtableFields_UNSTABLE = (subtableCode) => {
+  const schema = getSchema();
+  const subtable = schema?.subTable;
+  if (!subtable) {
+    return null;
+  }
+  const subtableList = Object.values(subtable);
+  for (const subtable2 of subtableList) {
+    const fieldList = subtable2?.fieldList;
+    if (!fieldList) {
+      continue;
+    }
+    if (subtable2?.var === subtableCode) {
+      return Object.values(fieldList);
+    }
+  }
+  return null;
+};
+var getQueryString_UNSTABLE = () => {
+  return cybozu?.data?.page?.QUERY_STRING ?? new URLSearchParams(location.search).get("q") ?? "";
+};
+
+// src/cybozu-api/common.ts
+var buildPath = (endpointName) => {
+  return kintone.api.url(`/v1/${endpointName}`);
+};
+var api = async (params) => {
+  const { endpointName, method, body, debug } = params;
+  try {
+    checkBrowser();
+    const path = buildPath(endpointName);
+    if (debug) {
+      console.groupCollapsed(
+        `%ckintone REST API %c(${endpointName})`,
+        "color: #1e40af;",
+        "color: #aaa"
+      );
+      console.log(`path: ${path}`);
+      console.log(`method: ${method}`);
+      console.log("body", body);
+    }
+    const response = await kintone.api(path, method, body);
+    if (debug) {
+      console.log("response", response);
+    }
+    return response;
+  } catch (error) {
+    if (debug) {
+      console.error(error);
+    }
+    throw error;
+  } finally {
+    if (debug) {
+      console.groupEnd();
+    }
+  }
+};
+var checkBrowser = () => {
+  if (typeof window === "undefined") {
+    throw new Error("\u3053\u306E\u95A2\u6570\u306F\u30D6\u30E9\u30A6\u30B6\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059");
+  }
+  if (typeof kintone === "undefined") {
+    throw new Error("kintone\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093");
+  }
+};
+
+// src/cybozu-api/group.ts
+function getCybozuGroups() {
+  return api({ endpointName: "groups", method: "GET", body: {} });
+}
+function getCybozuGroupUsers(groupCode) {
+  return api({ endpointName: "group/users", method: "GET", body: { code: groupCode } });
+}
+
+// src/cybozu-api/organization.ts
+function getCybozuOrganizations() {
+  return api({ endpointName: "organizations", method: "GET", body: {} });
+}
+function getCybozuOrganizationUsers(organizationCode) {
+  return api({
+    endpointName: "organization/users",
+    method: "GET",
+    body: { code: organizationCode }
+  });
+}
+
+// src/cybozu-api/user.ts
+var getCybozuUsers = () => {
+  return api({ endpointName: "users", method: "GET", body: {} });
+};
+var getCybozuUserGroups = (code) => {
+  return api({ endpointName: `user/groups`, method: "GET", body: { code } });
+};
+var getCybozuUserOrganizations = (code) => {
+  return api({ endpointName: `user/organizations`, method: "GET", body: { code } });
+};
+
+// src/date.ts
+var getWareki = (date, option) => {
+  const { era = "narrow" } = option || {};
+  const formatter = new Intl.DateTimeFormat("ja-JP-u-ca-japanese", { era });
+  const formatted = formatter.format(date);
+  const matched = formatted.match(/^(.*?)(\d+).*/);
+  if (!matched) {
+    throw new Error("\u548C\u66A6\u60C5\u5831\u306E\u30B3\u30F3\u30D0\u30FC\u30C8\u306B\u5931\u6557\u3057\u307E\u3057\u305F");
+  }
+  const [_, gengo, year] = matched;
+  return { gengo, year: Number(year) };
+};
+
+// src/decorator.ts
+var withLogging = (fn, name = fn.name) => {
+  return (...args) => {
+    try {
+      console.groupCollapsed(`\u{1F527} ${name}`);
+      console.log("\u{1F527} args", args);
+      const now = performance.now();
+      const result = fn(...args);
+      console.log("\u2728 result", result);
+      console.log(`\u{1F552} took ${performance.now() - now}ms`);
+      return result;
+    } finally {
+      console.groupEnd();
+    }
+  };
+};
+
+// src/xapp/xapp.ts
+var isMobile = (eventType) => {
+  if (eventType) {
+    return /^mobile\./.test(eventType);
+  }
+  return kintone.app.getId() === null;
+};
+var getAppObject = (eventType) => isMobile(eventType) ? kintone.mobile.app : kintone.app;
+var getAppId = () => getAppObject().getId();
+var getRecordId = () => getAppObject().record.getId();
+var getSpaceElement = (spaceId) => getAppObject().record.getSpaceElement(spaceId);
+var getQuery = () => getAppObject().getQuery();
+var getQueryCondition = () => getAppObject().getQueryCondition();
+var getCurrentRecord = () => getAppObject().record.get();
+var setCurrentRecord = (record) => getAppObject().record.set(record);
+var setFieldShown = (code, visible) => getAppObject().record.setFieldShown(String(code), visible);
+var getHeaderSpace = (eventType) => {
+  if (isMobile(eventType)) {
+    kintone.mobile.app.getHeaderSpaceElement();
+  } else if (!~eventType.indexOf("index")) {
+    return kintone.app.record.getHeaderMenuSpaceElement();
+  }
+  return kintone.app.getHeaderMenuSpaceElement();
+};
+var getFieldElement = (fieldCode) => {
+  return getAppObject().record.getFieldElement(fieldCode);
+};
+var getFieldElements = (fieldCode) => {
+  return getAppObject().getFieldElements(fieldCode);
+};
+
+// src/xapp/singleton.ts
+var xapp = getAppObject();
+
+// src/utilities.ts
+var getNumberFieldValueAsString = (params) => {
+  const { field: field2, property, locales = "ja" } = params;
+  const casted = Number(field2.value);
+  if (isNaN(casted)) {
+    return field2.value;
+  }
+  const displayScale = property?.displayScale ? Number(property.displayScale) : null;
+  const scaled = displayScale ? Math.round(casted * Math.pow(10, Number(displayScale))) / Math.pow(10, Number(displayScale)) : casted;
+  const separated = property?.digit ? Number(scaled).toLocaleString(locales, {
+    maximumFractionDigits: displayScale ?? void 0,
+    minimumFractionDigits: displayScale ?? void 0
+  }) : displayScale ? Number(scaled).toFixed(displayScale) : scaled;
+  if (property?.unit) {
+    if (property.unitPosition === "BEFORE") {
+      return `${property.unit}${separated}`;
+    } else {
+      return `${separated}${property.unit}`;
+    }
+  }
+  return String(separated);
+};
+var getFieldValueAsString = (field2, options) => {
+  const { separator = ", ", ignoresCalculationError = false } = options ?? {};
+  if (field2.type === "MULTI_LINE_TEXT" || field2.type === "RICH_TEXT" || field2.type === "CREATED_TIME" || field2.type === "DATE" || field2.type === "DATETIME" || field2.type === "DROP_DOWN" || field2.type === "LINK" || field2.type === "RECORD_NUMBER" || field2.type === "STATUS" || field2.type === "RADIO_BUTTON" || field2.type === "TIME" || field2.type === "UPDATED_TIME" || field2.type === "__ID__" || field2.type === "__REVISION__") {
+    return field2.value ?? "";
+  } else if (field2.type === "SINGLE_LINE_TEXT" || field2.type === "NUMBER" || field2.type === "CALC") {
+    const value = field2.value ?? "";
+    if (ignoresCalculationError) {
+      return /^#.*!$/.test(value) ? "" : value;
+    }
+    return value;
+  } else if (field2.type === "CATEGORY" || field2.type === "CHECK_BOX" || field2.type === "MULTI_SELECT") {
+    return field2.value.join(separator);
+  } else if (field2.type === "CREATOR" || field2.type === "MODIFIER") {
+    return field2.value.name;
+  } else if (field2.type === "GROUP_SELECT" || field2.type === "ORGANIZATION_SELECT" || field2.type === "USER_SELECT" || field2.type === "STATUS_ASSIGNEE") {
+    return field2.value.map((value) => value.name).join(separator);
+  } else if (field2.type === "FILE") {
+    return field2.value.map((value) => value.name).join(separator);
+  } else if (field2.type === "SUBTABLE") {
+    return field2.value.map(
+      (row) => Object.values(row.value).map((cell) => getFieldValueAsString(cell, { separator })).join(separator)
+    ).join(separator);
+  }
+  return "";
+};
+var isStringField = (field2) => {
+  return field2.type === "SINGLE_LINE_TEXT" || field2.type === "MULTI_LINE_TEXT" || field2.type === "RICH_TEXT" || field2.type === "DROP_DOWN" || field2.type === "LINK" || field2.type === "RECORD_NUMBER" || field2.type === "STATUS" || field2.type === "RADIO_BUTTON" || field2.type === "__ID__" || field2.type === "__REVISION__";
+};
+var isNumberField = (field2) => {
+  return field2.type === "NUMBER" || field2.type === "CALC";
+};
+var isDateField = (field2) => {
+  return field2.type === "CREATED_TIME" || field2.type === "UPDATED_TIME" || field2.type === "DATE" || field2.type === "DATETIME";
+};
+var isTimeField = (field2) => {
+  return field2.type === "TIME";
+};
+var sortField = (aField, bField) => {
+  const aFieldType = aField.type;
+  const bFieldType = bField.type;
+  if (aField.value === null && bField.value === null) {
+    return 0;
+  }
+  if (aField.value === null) {
+    return 1;
+  }
+  if (bField.value === null) {
+    return -1;
+  }
+  if (aFieldType === "RECORD_NUMBER" && bFieldType === "RECORD_NUMBER") {
+    const regex = /.*?(\d+)$/;
+    const aMatch = aField.value.match(regex);
+    const bMatch = bField.value.match(regex);
+    if (aMatch && bMatch) {
+      const aNumber = Number(aMatch[1]);
+      const bNumber = Number(bMatch[1]);
+      if (isNaN(aNumber) && isNaN(bNumber)) {
+        return 0;
+      }
+      return Number(aMatch[1]) - Number(bMatch[1]);
+    }
+    return aField.value.localeCompare(bField.value);
+  } else if (isStringField(aField) && isStringField(bField)) {
+    return aField.value?.localeCompare(bField.value ?? "") ?? 0;
+  } else if (isNumberField(aField) && isNumberField(bField)) {
+    const aNum = Number(aField.value);
+    const bNum = Number(bField.value);
+    if (isNaN(aNum) && isNaN(bNum)) {
+      return 0;
+    }
+    if (isNaN(aNum)) {
+      return 1;
+    }
+    if (isNaN(bNum)) {
+      return -1;
+    }
+    return aNum - bNum;
+  } else if (isDateField(aField) && isDateField(bField)) {
+    const aDate = new Date(aField.value);
+    const bDate = new Date(bField.value);
+    if (isNaN(aDate.getTime()) && isNaN(bDate.getTime())) {
+      return 0;
+    }
+    if (isNaN(aDate.getTime())) {
+      return 1;
+    }
+    if (isNaN(bDate.getTime())) {
+      return -1;
+    }
+    return aDate.getTime() - bDate.getTime();
+  } else if (isTimeField(aField) && isTimeField(bField)) {
+    const parseTime = (value) => {
+      const [hours, minutes] = value.split(":").map(Number);
+      if (isNaN(hours) || isNaN(minutes)) {
+        return NaN;
+      }
+      return hours * 60 + minutes;
+    };
+    const aTime = parseTime(aField.value);
+    const bTime = parseTime(bField.value);
+    if (isNaN(aTime) && isNaN(bTime)) {
+      return 0;
+    }
+    if (isNaN(aTime)) {
+      return 1;
+    }
+    if (isNaN(bTime)) {
+      return -1;
+    }
+    return aTime - bTime;
+  } else if ((aFieldType === "CATEGORY" || aFieldType === "CHECK_BOX" || aFieldType === "MULTI_SELECT") && (bFieldType === "CATEGORY" || bFieldType === "CHECK_BOX" || bFieldType === "MULTI_SELECT")) {
+    return getFieldValueAsString(aField).localeCompare(getFieldValueAsString(bField));
+  } else if ((aFieldType === "CREATOR" || aFieldType === "MODIFIER") && (bFieldType === "CREATOR" || bFieldType === "MODIFIER")) {
+    return aField.value.name.localeCompare(bField.value.name);
+  } else if ((aFieldType === "GROUP_SELECT" || aFieldType === "ORGANIZATION_SELECT" || aFieldType === "USER_SELECT" || aFieldType === "STATUS_ASSIGNEE") && (bFieldType === "GROUP_SELECT" || bFieldType === "ORGANIZATION_SELECT" || bFieldType === "USER_SELECT" || bFieldType === "STATUS_ASSIGNEE")) {
+    return getFieldValueAsString(aField).localeCompare(getFieldValueAsString(bField));
+  } else if (aFieldType === "FILE" && bFieldType === "FILE") {
+    return getFieldValueAsString(aField).localeCompare(getFieldValueAsString(bField));
+  } else if (aFieldType === "SUBTABLE" && bFieldType === "SUBTABLE") {
+    return getFieldValueAsString(aField).localeCompare(getFieldValueAsString(bField));
+  }
+  return 0;
+};
+var getCalcFieldValueAsString = (params) => {
+  const { field: field2, property } = params;
+  const { unit, unitPosition, format } = property;
+  let fieldValue = "";
+  switch (format) {
+    case "NUMBER_DIGIT":
+      if (property.displayScale) {
+        const displayScale = Number(property.displayScale || 0);
+        const scaled = Math.round(Number(field2.value) * 10 ** displayScale) / 10 ** displayScale;
+        fieldValue = scaled.toLocaleString();
+      } else {
+        fieldValue = Number(field2.value).toLocaleString();
+      }
+      break;
+    case "DATE":
+      fieldValue = new Date(field2.value).toLocaleDateString();
+      break;
+    case "TIME":
+      fieldValue = new Date(field2.value).toLocaleTimeString();
+      break;
+    case "DATETIME":
+      fieldValue = new Date(field2.value).toLocaleString();
+      break;
+    case "HOUR_MINUTE":
+      const [h, m] = field2.value.split(":");
+      fieldValue = `${h}\u6642\u9593${m}\u5206`;
+      break;
+    case "DAY_HOUR_MINUTE":
+      const [hourString, minute] = field2.value.split(":");
+      const hour = Number(hourString);
+      const day = Math.floor(hour / 24);
+      const hourInDay = hour % 24;
+      fieldValue = `${day}\u65E5${hourInDay}\u6642\u9593${minute}\u5206`;
+      break;
+    default:
+      fieldValue = field2.value;
+  }
+  if (unit) {
+    if (unitPosition === "BEFORE") {
+      fieldValue = unit + fieldValue;
+    } else {
+      fieldValue += unit;
+    }
+  }
+  return fieldValue;
+};
+var getEmptyValue = (params) => {
+  let type;
+  if ("type" in params) {
+    type = params.type;
+  } else {
+    type = params.field.type;
+  }
+  switch (type) {
+    case "__ID__":
+    case "__REVISION__":
+    case "CALC":
+    case "CREATED_TIME":
+    case "UPDATED_TIME":
+    case "CREATOR":
+    case "MODIFIER":
+      if ("field" in params) {
+        console.warn(
+          `[kintone-utilities]: ${params.field.type}\u306F\u30AF\u30EA\u30A2\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u51E6\u7406\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u307E\u3057\u305F`
+        );
+        return params.field.value;
+      }
+      return null;
+    case "SINGLE_LINE_TEXT":
+    case "NUMBER":
+    case "MULTI_LINE_TEXT":
+    case "RICH_TEXT":
+    case "DATE":
+    case "TIME":
+    case "DATETIME":
+    case "DROP_DOWN":
+    case "LINK":
+    case "RECORD_NUMBER":
+    case "STATUS":
+    case "RADIO_BUTTON":
+      return "";
+    case "CATEGORY":
+    case "CHECK_BOX":
+    case "MULTI_SELECT":
+    case "USER_SELECT":
+    case "GROUP_SELECT":
+    case "ORGANIZATION_SELECT":
+    case "STATUS_ASSIGNEE":
+    case "FILE":
+      return [];
+    case "SUBTABLE":
+      if ("field" in params) {
+        return params.field.value.map((row) => ({
+          ...row,
+          value: Object.entries(row.value).reduce(
+            (acc, [key, cell]) => ({ ...acc, [key]: getEmptyValue(cell) }),
+            {}
+          )
+        }));
+      }
+    default:
+      throw new Error(`\u672A\u5BFE\u5FDC\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u30BF\u30A4\u30D7\u3067\u3059: ${field.type}`);
+  }
+};
+var getDefaultValue = (property) => {
+  switch (property.type) {
+    case "SINGLE_LINE_TEXT":
+    case "NUMBER":
+    case "MULTI_LINE_TEXT":
+    case "RICH_TEXT":
+    case "DROP_DOWN":
+    case "RADIO_BUTTON":
+    case "LINK":
+      return "defaultValue" in property ? property.defaultValue ?? "" : "";
+    case "DATE":
+      const { defaultValue, defaultNowValue } = property;
+      if (defaultValue) {
+        return defaultValue;
+      }
+      return defaultNowValue ? (/* @__PURE__ */ new Date()).toISOString().split("T")[0] : "";
+    case "TIME":
+      const { defaultNowValue: n, defaultValue: v } = property;
+      if (v) {
+        return v;
+      }
+      return n ? (/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0] : "";
+    case "DATETIME":
+      const { defaultNowValue: now, defaultValue: value } = property;
+      if (value) {
+        return value;
+      }
+      return now ? (/* @__PURE__ */ new Date()).toISOString() : "";
+    case "CHECK_BOX":
+    case "MULTI_SELECT":
+    case "USER_SELECT":
+    case "GROUP_SELECT":
+    case "ORGANIZATION_SELECT":
+      if (!("defaultValue" in property)) {
+        return [];
+      }
+      const { defaultValue: d } = property;
+      return d.map((v2) => {
+        if (typeof v2 === "string") {
+          return { code: v2, name: v2 };
+        }
+        switch (v2.type) {
+          case "USER":
+          case "GROUP":
+          case "ORGANIZATION":
+            return { code: v2.code, name: v2.code };
+          case "FUNCTION":
+            if (v2.code === "LOGINUSER()") {
+              const loginUser = kintone.getLoginUser();
+              return { code: loginUser.code, name: loginUser.name };
+            }
+            return [];
+          default:
+            return [];
+        }
+      });
+    case "STATUS":
+    case "CATEGORY":
+    case "RECORD_NUMBER":
+      return null;
+  }
+};
+var compareField = (field1, field2, options) => {
+  const { ignoresType = false } = options ?? {};
+  if (!ignoresType && field1.type !== field2.type) {
+    return false;
+  }
+  const separator = "$";
+  return getFieldValueAsString(field1, { separator }) === getFieldValueAsString(field2, { separator });
+};
+var withMobileEvents = (events) => {
+  const mobileEvents = events.filter((e) => !/^mobile/.test(e)).map((type) => "mobile." + type);
+  return [.../* @__PURE__ */ new Set([...events, ...mobileEvents])];
+};
+var detectGuestSpaceId = () => {
+  const match = location.pathname.match(/^\/k\/guest\/(\d+)\//);
+  return match ? match[1] : null;
+};
+var onFileLoad = (file, options) => {
+  const { encoding = "utf-8" } = options ?? {};
+  return new Promise((resolve, reject) => {
+    try {
+      const reader = new FileReader();
+      reader.readAsText(file, encoding);
+      reader.onload = (event) => resolve(event);
+      reader.onerror = (event) => reject(event);
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+var getSortFromQuery = (query) => {
+  const sort = query.match(/order by (.*)?(?=( limit | offset|$))/)?.[1];
+  if (!sort) {
+    return [];
+  }
+  return sort.split(",").map((s) => {
+    const [field2, order] = s.trim().split(" ");
+    return { field: field2, order };
+  });
+};
+
+// src/event-manager.ts
+var KintoneEventManager = class {
+  #uid = Math.random().toString(36).slice(2);
+  #pluginId;
+  #commonErrorHandler;
+  #guestSpaceId;
+  #logDisabled;
+  #logPrefix;
+  /**
+   * 複数の処理を、各イベントに登録することができます
+   */
+  constructor(props) {
+    const {
+      errorHandler = (error) => {
+        throw error;
+      },
+      pluginId,
+      logDisabled = false,
+      logPrefix = ""
+    } = props ?? {};
+    const guestSpaceId = detectGuestSpaceId();
+    this.#commonErrorHandler = errorHandler;
+    this.#pluginId = pluginId;
+    this.#guestSpaceId = guestSpaceId;
+    this.#logDisabled = logDisabled;
+    this.#logPrefix = logPrefix;
+  }
+  /**
+   * **この関数は`kintone.events.on`の代替関数です. 引数に互換性があります.**
+   *
+   * デスクトップ版のイベントを指定することで自動的に対応するモバイル版のイベントが登録されます.
+   * また、インスタンス作成時に指定したエラーハンドラが、コールバック関数のエラー発生時に実行されます
+   * @param events
+   * @param callback
+   */
+  add = (events, callback) => {
+    kintone.events.on(withMobileEvents(events), async (event) => {
+      try {
+        this.initialize(event);
+        return await callback(event, {
+          pluginId: this.#pluginId,
+          guestSpaceId: this.#guestSpaceId
+        });
+      } catch (error) {
+        return await this.#commonErrorHandler(error, { event });
+      } finally {
+        this.tarminate();
+      }
+    });
+  };
+  /**
+   * Changeイベントを登録します
+   *
+   * ChangeイベントはPromiseオブジェクトを返却することができません
+   * @param events
+   * @param callback
+   */
+  addChangeEvents = (events, callback) => {
+    kintone.events.on(withMobileEvents(events), (event) => {
+      try {
+        this.initialize(event);
+        return callback(event, { pluginId: this.#pluginId, guestSpaceId: this.#guestSpaceId });
+      } catch (error) {
+        return this.#commonErrorHandler(error, { event });
+      } finally {
+        this.tarminate();
+      }
+    });
+  };
+  addHeaderButton(params) {
+    const {
+      id,
+      label,
+      color = "default",
+      onClick,
+      isButtonHidden,
+      events,
+      isTolerantToFailure = false
+    } = params;
+    this.addButtonStyle();
+    this.add(events, async (event) => {
+      if (isButtonHidden && await isButtonHidden(event)) {
+        return event;
+      }
+      if (document.getElementById(id)) {
+        return event;
+      }
+      const headerSpace = getHeaderSpace(event.type);
+      if (!headerSpace) {
+        const message = `\u30D8\u30C3\u30C0\u30FC\u306B\u30DC\u30BF\u30F3\u3092\u8FFD\u52A0\u3059\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002${event.type}\u30A4\u30D9\u30F3\u30C8\u304C\u767A\u751F\u3057\u305F\u30BF\u30A4\u30DF\u30F3\u30B0\u306B\u306F\u3001\u5BFE\u8C61\u8981\u7D20\u304C\u5B58\u5728\u3057\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059`;
+        if (!isTolerantToFailure) {
+          throw new Error(message);
+        }
+        console.error(message);
+        return event;
+      }
+      const root = document.createElement("button");
+      root.id = id;
+      root.textContent = label;
+      root.className = "rkemb";
+      root.dataset.color = color;
+      root.addEventListener("click", onClick);
+      headerSpace.append(root);
+      return event;
+    });
+  }
+  addButtonStyle = () => {
+    if (document.querySelector("style[data-rkem]")) {
+      return;
+    }
+    const style = document.createElement("style");
+    style.dataset.rkem = "";
+    document.head.append(style);
+    style.textContent = `
+
+:root {
+  --rkemb-color-blue-lighter: #57aae1;
+  --rkemb-color-blue-light: #4ba4df;
+  --rkemb-color-blue: #3498db;
+  --rkemb-color-blue-dark: #258bcf;
+  --rkemb-color-blue-darker: #2383c4;
+}
+
+.rkemb {
+  font-size: 16px;
+  font-family: Yu Gothic Meduim, "\u6E38\u30B4\u30B7\u30C3\u30AF Medium", "\u6E38\u30B4\u30B7\u30C3\u30AF\u4F53", YuGothic, "\u6E38\u30B4\u30B7\u30C3\u30AF", "\u30E1\u30A4\u30EA\u30AA", sans-serif;
+  display: inline-flex;
+  justify-content: center;
+  margin: 0 4px;
+  padding: 0 16px;
+  min-width: 160px;
+  height: 48px;
+  outline: none;
+  color: #3498db;
+  border-radius: 4px;
+  text-align: center;
+  line-height: 48px;
+  transition: all 250ms ease;
+  border: 0;
+  border: 1px solid;
+}
+.rkemb[data-color="default"] {
+  background-color: #f9fafb;
+  color: var(--rkemb-color-blue);
+  border-color: #e5e7eb;
+}
+.rkemb[data-color="default"]:hover {
+  background-color: #f3f4f6;
+}
+.rkemb[data-color="default"]:active {
+  background-color: #e5e7eb;
+  color: var(--rkemb-color-blue-darker);
+}
+.rkemb[data-color="default"]:focus {
+  box-shadow: 0 0 0 2px #fff, 0 0 0 3px #d1d5db;
+}
+.rkemb[data-color="blue"] {
+  background-color: #eff6ff;
+  color: var(--rkemb-color-blue);
+  border-color: #bfdbfe;
+}
+.rkemb[data-color="blue"]:hover {
+  background-color: #dbeafe;
+}
+.rkemb[data-color="blue"]:active {
+  background-color: #bfdbfe;
+  color: var(--rkemb-color-blue-darker);
+}
+.rkemb[data-color="blue"]:focus {
+  box-shadow: 0 0 0 2px #fff, 0 0 0 3px #93c5fd;
+}
+.rkemb[data-color="red"] {
+  background-color: #fef2f2;
+  color: #ef4444;
+  border-color: #fecaca;
+}
+.rkemb[data-color="red"]:hover {
+  background-color: #fee2e2;
+}
+.rkemb[data-color="red"]:active {
+  background-color: #fecaca;
+  color: #dc2626;
+}
+.rkemb[data-color="red"]:focus {
+  box-shadow: 0 0 0 2px #fff, 0 0 0 3px #fca5a5;
+}
+.rkemb[data-color="yellow"] {
+  background-color: #fffbeb;
+  color: #f59e0b;
+  border-color: #fde68a;
+}
+.rkemb[data-color="yellow"]:hover {
+  background-color: #fef3c7;
+}
+.rkemb[data-color="yellow"]:active {
+  background-color: #fde68a;
+  color: #d97706;
+}
+.rkemb[data-color="yellow"]:focus {
+  box-shadow: 0 0 0 2px #fff, 0 0 0 3px #fcd34d;
+}
+    `;
+  };
+  initialize = (event) => {
+    window.addEventListener("beforeunload", this.beforeunload);
+    if (!this.#logDisabled) {
+      console.group(
+        `${this.#logPrefix}%c${event.type} %c(${this.#uid})`,
+        "color: #1e40af;",
+        "color: #aaa"
+      );
+    }
+  };
+  tarminate = () => {
+    window.removeEventListener("beforeunload", this.beforeunload);
+    if (!this.#logDisabled) {
+      console.groupEnd();
+    }
+  };
+  set logDisabled(value) {
+    this.#logDisabled = value;
+  }
+  set logPrefix(value) {
+    this.#logPrefix = value;
+  }
+  /** JavaScript中にページを離れようとした場合にアラートを表示します */
+  beforeunload(event) {
+    event.preventDefault();
+    event.returnValue = "";
+  }
+};
+var KintoneEventListener = KintoneEventManager;
+
+// src/plugin/config.ts
+var META_PROPERTY_KEY = "$meta";
+var restoreStorage = (id) => {
+  const config = kintone.plugin.app.getConfig(id);
+  if (!Object.keys(config).length) {
+    return null;
+  }
+  return Object.entries(config).reduce(
+    (acc, [key, value]) => ({ ...acc, [key]: JSON.parse(value) }),
+    {}
+  );
+};
+var storeStorage = (target, callback) => {
+  const converted = Object.entries(target).filter(([_, v]) => v !== void 0).reduce((acc, [key, value]) => ({ ...acc, [key]: JSON.stringify(value) }), {});
+  kintone.plugin.app.setConfig(converted, callback);
+};
+var createFlatPropertyKey = (property, id) => `${property}$${id}`;
+var restorePluginConfig = (id, options = {}) => {
+  const { fallback, debug = false } = options;
+  const config = kintone.plugin.app.getConfig(id);
+  debug && console.log("[config] \u{1F4E6} stored", config);
+  if (!Object.keys(config).length) {
+    return fallback ?? null;
+  }
+  if (!(META_PROPERTY_KEY in config)) {
+    debug && console.warn("[config] Meta property is not found. Fallback to normal config.");
+    return Object.entries(config).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: JSON.parse(value) }),
+      {}
+    );
+  }
+  const meta = JSON.parse(config[META_PROPERTY_KEY]);
+  let composed = {};
+  const flatKeys = meta.flat.flatMap(
+    ({ ids, property }) => ids.map((id2) => createFlatPropertyKey(property, id2))
+  );
+  for (const { property, ids } of meta.flat) {
+    const properties = ids.map((id2) => ({ id: id2, key: createFlatPropertyKey(property, id2) })).filter(({ key }) => {
+      if (!(key in config)) {
+        console.warn(`[config] Property "${key}" is not found.`);
+        return false;
+      }
+      return true;
+    }).map(({ id: id2, key }) => {
+      return { id: id2, ...JSON.parse(config[key]) };
+    });
+    composed = { ...composed, [property]: properties };
+  }
+  const rest = Object.entries(config).reduce((acc, [key, value]) => {
+    if (![META_PROPERTY_KEY, ...flatKeys].includes(key)) {
+      return { ...acc, [key]: JSON.parse(value) };
+    }
+    return acc;
+  }, {});
+  debug && console.log("[config] \u{1F4E6} Composed:", { ...rest, ...composed });
+  return { ...rest, ...composed };
+};
+var storePluginConfig = (target, options) => {
+  const { flatProperties = [], debug = false } = options || {};
+  const meta = {
+    v: 1,
+    flat: []
+  };
+  let decomposed = {};
+  let appliedProperties = [];
+  for (const property of flatProperties) {
+    if (typeof property !== "string") {
+      debug && console.warn("[config] Property name should be a string.");
+      continue;
+    }
+    if (!(property in target) || !Array.isArray(target[property])) {
+      debug && console.warn(`[config] Property "${property}" is not found or not an array.`);
+      continue;
+    }
+    if (target[property].some((item) => !("id" in item))) {
+      debug && console.warn(`[config] Property "${property}" has an item without "id" property.`);
+      continue;
+    }
+    const ids = target[property].map((item) => item.id);
+    const decomposedProperties = target[property].reduce((acc, item) => {
+      const { id, ...rest } = item;
+      const key = createFlatPropertyKey(property, id);
+      return { ...acc, [key]: JSON.stringify(rest) };
+    }, {});
+    meta.flat.push({ property, ids });
+    decomposed = { ...decomposed, ...decomposedProperties };
+    appliedProperties.push(property);
+  }
+  const converted = Object.entries(target).filter(([key]) => !appliedProperties.includes(key)).reduce((acc, [key, value]) => ({ ...acc, [key]: JSON.stringify(value) }), {});
+  const result = { [META_PROPERTY_KEY]: JSON.stringify(meta), ...converted, ...decomposed };
+  debug && console.log("[config] \u{1F4E6} Converted:", result);
+  return new Promise((resolve) => {
+    kintone.plugin.app.setConfig(result, () => {
+      resolve();
+    });
+  });
+};
+function setPluginProxyConfig(url, method, headers, data) {
+  return new Promise((resolve) => {
+    kintone.plugin.app.setProxyConfig(url, method, headers, data, () => {
+      resolve();
+    });
+  });
+}
+
+// src/plugin/local-storage.ts
+var PluginLocalStorage = class {
+  #key;
+  #storage;
+  constructor(key) {
+    this.#key = key;
+    const stored = localStorage.getItem(this.#key) ?? "{}";
+    this.#storage = JSON.parse(stored);
+  }
+  save() {
+    localStorage.setItem(this.#key, JSON.stringify(this.#storage));
+  }
+  updateVersion = (currentVersion) => {
+    const latestVersion = this.#storage.latestVersion ?? currentVersion;
+    this.#storage.version = currentVersion;
+    const [latestMajor, latestMinor] = latestVersion.split(".").map((v) => parseInt(v, 10));
+    const [currentMajor, currentMinor] = currentVersion.split(".").map((v) => parseInt(v, 10));
+    this.#storage.hasNewVersion = latestMajor > currentMajor || latestMajor === currentMajor && latestMinor > currentMinor;
+    this.save();
+  };
+  get hasNewVersion() {
+    return this.#storage.hasNewVersion ?? false;
+  }
+};
+
+// src/rest-api/common.ts
+var buildPath2 = (params) => {
+  const { endpointName, guestSpaceId, preview } = params;
+  const guestPath = guestSpaceId !== void 0 ? `/guest/${guestSpaceId}` : "";
+  const previewPath = preview ? "/preview" : "";
+  return `/k${guestPath}/v1${previewPath}/${endpointName}.json`;
+};
+var api2 = async (params) => {
+  const { endpointName, method, body, guestSpaceId, preview, debug } = params;
+  try {
+    checkBrowser2();
+    const path = buildPath2({ endpointName, guestSpaceId, preview });
+    if (debug) {
+      console.log(`%ckintone REST API %c(${endpointName})`, "color: #1e40af;", "color: #aaa", {
+        path,
+        method,
+        body
+      });
+    }
+    const response = await kintone.api(path, method, body);
+    if (debug) {
+      console.log("response", response);
+    }
+    return response;
+  } catch (error) {
+    if (debug) {
+      console.error(error);
+    }
+    throw error;
+  } finally {
+    if (debug) {
+      console.groupEnd();
+    }
+  }
+};
+var checkBrowser2 = () => {
+  if (typeof window === "undefined") {
+    throw new Error("\u3053\u306E\u95A2\u6570\u306F\u30D6\u30E9\u30A6\u30B6\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059");
+  }
+  if (typeof kintone === "undefined") {
+    throw new Error("kintone\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093");
+  }
+};
+var sliceIntoChunks = (array, size) => {
+  const result = [];
+  for (let i = 0, j = array.length; i < j; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+};
+
+// src/rest-api/app.ts
+var API_LIMIT_APP = 100;
+var API_ENDPOINT_APP = `app`;
+var API_ENDPOINT_APPS = `apps`;
+var API_ENDPOINT_VIEWS = "app/views";
+var API_ENDPOINT_FORM_FIELDS = "app/form/fields";
+var API_ENDPOINT_FORM_LAYOUT = "app/form/layout";
+var API_ENDPOINT_APP_SETTINGS = "app/settings";
+var getApp = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_APP,
+    method: "GET",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var getApps = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_APPS,
+    method: "GET",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var getAllApps = async (params = {}) => {
+  const { offset = 0, _apps = [], debug, guestSpaceId } = params;
+  const { apps } = await getApps({ limit: API_LIMIT_APP, offset, debug, guestSpaceId });
+  const allApps = [..._apps, ...apps];
+  return apps.length === API_LIMIT_APP ? getAllApps({ offset: offset + API_LIMIT_APP, _apps: allApps, debug, guestSpaceId }) : allApps;
+};
+var getViews = async (params) => {
+  const { app, preview = false, lang = "default", debug, guestSpaceId } = params;
+  return api2({
+    endpointName: API_ENDPOINT_VIEWS,
+    method: "GET",
+    body: { app, lang },
+    preview,
+    debug,
+    guestSpaceId
+  });
+};
+var updateViews = async (params) => {
+  const { app, views, debug, guestSpaceId } = params;
+  return api2({
+    endpointName: API_ENDPOINT_VIEWS,
+    method: "PUT",
+    body: { app, views },
+    preview: true,
+    debug,
+    guestSpaceId
+  });
+};
+var getFormFields = async (params) => {
+  const { app, preview = false, debug, guestSpaceId } = params;
+  return api2({
+    endpointName: API_ENDPOINT_FORM_FIELDS,
+    method: "GET",
+    body: { app },
+    preview,
+    debug,
+    guestSpaceId
+  });
+};
+var getFormLayout = async (params) => {
+  const { app, preview = false, debug, guestSpaceId } = params;
+  return api2({
+    endpointName: API_ENDPOINT_FORM_LAYOUT,
+    method: "GET",
+    body: { app },
+    preview,
+    debug,
+    guestSpaceId
+  });
+};
+var getAppSettings = async (params) => {
+  const { app, preview = false, debug, guestSpaceId } = params;
+  return api2({
+    endpointName: API_ENDPOINT_APP_SETTINGS,
+    method: "GET",
+    body: { app },
+    preview,
+    debug,
+    guestSpaceId
+  });
+};
+
+// src/rest-api/record.ts
+var API_ENDPOINT_RECORD = `record`;
+var API_ENDPOINT_RECORDS = `records`;
+var API_ENDPOINT_CURSOR = `records/cursor`;
+var API_ENDPOINT_ASSIGNEES = `record/assignees`;
+var API_ENDPOINT_RECORD_STATUS = `record/status`;
+var API_ENDPOINT_RECORD_STATUSES = `records/status`;
+var API_ENDPOINT_ACL_EVALUATE = `records/acl/evaluate`;
+var API_ENDPOINT_BULK = `bulkRequest`;
+var API_LIMIT_GET = 500;
+var API_LIMIT_PUT = 100;
+var API_LIMIT_POST = 100;
+var API_LIMIT_DELETE = 100;
+var API_LIMIT_BULK_REQUEST = 20;
+var backdoor = async (params) => {
+  checkBrowser2();
+  const { apiToken, method, path, body } = params;
+  const header = {
+    "X-Cybozu-API-Token": apiToken
+  };
+  if (method !== "GET") {
+    header["Content-Type"] = "application/json";
+  }
+  const uri = kintone.api.url(path, true);
+  const response = await kintone.proxy(uri, method, header, body);
+  if (response[1] !== 200) {
+    throw new Error(`Backdoor API Error: ${response[1]} ${response[0]}`);
+  }
+  return JSON.parse(response[0]);
+};
+var getRecord = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  const { record } = await api2({
+    endpointName: API_ENDPOINT_RECORD,
+    method: "GET",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+  return record;
+};
+var backdoorGetRecord = async (params) => {
+  const { app, id, apiToken } = params;
+  const { record } = await backdoor({
+    apiToken,
+    method: "GET",
+    path: API_ENDPOINT_RECORD,
+    body: { app, id }
+  });
+  return record;
+};
+var getRecords = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return await api2({
+    endpointName: API_ENDPOINT_RECORDS,
+    method: "GET",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var updateRecord = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_RECORD,
+    method: "PUT",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var addRecord = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_RECORD,
+    method: "POST",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var addRecords = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_RECORDS,
+    method: "POST",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var upsertRecord = async (params) => {
+  const { record, updateKey, app, ...rest } = params;
+  const { records } = await getRecords({
+    app,
+    query: `${updateKey.field} = "${updateKey.value}"`,
+    fields: ["$id"],
+    ...rest
+  });
+  if (records.length) {
+    const res = await updateRecord({
+      app,
+      record,
+      id: records[0].$id.value,
+      ...rest
+    });
+    return { id: records[0].$id.value, revision: res.revision };
+  }
+  return addRecord({ app, record, ...rest });
+};
+var updateAllRecords = async (params) => {
+  const { onProgress, debug, guestSpaceId, ...requestParams } = params;
+  const response = await bulkRequest({
+    requests: [{ type: "updateAllRecords", params: requestParams }],
+    onProgress,
+    debug,
+    guestSpaceId
+  });
+  return response.results.reduce(
+    (acc, result) => {
+      return { records: [...acc.records, ...result.records] };
+    },
+    { records: [] }
+  );
+};
+var addAllRecords = async (params) => {
+  const { onProgress, debug, guestSpaceId, ...requestParams } = params;
+  if (requestParams.records.length === 0) {
+    if (debug) {
+      console.log("\u{1F615} %caddAllRecords: No records to add", "color: #fbbf24");
+    }
+    return { ids: [], revisions: [] };
+  }
+  const responses = await bulkRequest({
+    requests: [{ type: "addAllRecords", params: requestParams }],
+    onProgress,
+    debug,
+    guestSpaceId
+  });
+  return responses.results.reduce(
+    (acc, result) => {
+      return {
+        ids: [...acc.ids, ...result.ids],
+        revisions: [...acc.revisions, ...result.revisions]
+      };
+    },
+    { ids: [], revisions: [] }
+  );
+};
+var deleteAllRecords = async (params) => {
+  const { onProgress, debug, guestSpaceId, ...requestParams } = params;
+  return bulkRequest({
+    requests: [{ type: "deleteRecords", params: requestParams }],
+    onProgress,
+    debug,
+    guestSpaceId
+  });
+};
+var deleteAllRecordsByQuery = async (params) => {
+  const { onProgress, debug, guestSpaceId, app, query } = params;
+  const fields = ["$id"];
+  const records = await getAllRecords({ app, query, fields, debug, guestSpaceId });
+  const ids = records.map((record) => Number(record.$id.value));
+  return bulkRequest({
+    requests: [{ type: "deleteRecords", params: { app, ids } }],
+    onProgress,
+    debug,
+    guestSpaceId
+  });
+};
+var getAllRecords = async (params) => {
+  if (params.query && /limit \d+/.test(params.query)) {
+    const { records } = await getRecords(params);
+    return records;
+  }
+  if (params.query && params.query.includes("order by")) {
+    return getAllRecordsWithCursor(params);
+  }
+  return getAllRecordsWithId({ ...params, condition: params.query });
+};
+var getAllRecordsWithId = async (params) => {
+  const { fields: initFields, condition: initCondition = "", debug } = params;
+  const fields = initFields?.length ? [.../* @__PURE__ */ new Set([...initFields, "$id"])] : void 0;
+  const condition = initCondition.replace(/order by.*/g, "");
+  if (debug) {
+    console.groupCollapsed("\u{1F4E6} %cgetAllRecordsWithId", "color: #1e40af");
+  }
+  try {
+    const records = await getRecursive({ ...params, fields, condition });
+    return records;
+  } finally {
+    if (debug) {
+      console.groupEnd();
+    }
+  }
+};
+var getRecursive = async (params) => {
+  const { app, fields, condition, id, debug, guestSpaceId } = params;
+  const newCondition = id ? `${condition ? `(${condition}) and ` : ""} $id < ${id}` : condition;
+  const query = `${newCondition} order by $id desc limit ${API_LIMIT_GET}`;
+  const { records } = await api2({
+    endpointName: API_ENDPOINT_RECORDS,
+    method: "GET",
+    body: { app, fields, query },
+    debug,
+    guestSpaceId
+  });
+  if (!records.length) {
+    return params.stored ?? [];
+  }
+  const stored = [...params.stored ?? [], ...records];
+  if (params.onStep) {
+    params.onStep({ records: stored, incremental: records });
+  }
+  const lastRecord = stored[stored.length - 1];
+  const lastId = lastRecord.$id.value;
+  return records.length === API_LIMIT_GET ? getRecursive({ ...params, id: lastId, stored }) : stored;
+};
+var getAllRecordsWithCursor = async (params) => {
+  const {
+    app,
+    fields = [],
+    query = "",
+    onTotalGet = null,
+    onStep = null,
+    debug,
+    guestSpaceId
+  } = params;
+  if (debug) {
+    console.groupCollapsed("\u{1F4E6} %cgetAllRecordsWithCursor", "color: #1e40af");
+  }
+  try {
+    const param = { app, fields, size: API_LIMIT_GET, query };
+    const cursor = await api2({
+      endpointName: API_ENDPOINT_CURSOR,
+      method: "POST",
+      body: param,
+      debug,
+      guestSpaceId
+    });
+    if (onTotalGet) {
+      onTotalGet({
+        total: Number(cursor.totalCount)
+      });
+    }
+    const records = await getRecordsByCursorId({ id: cursor.id, onStep, debug, guestSpaceId });
+    return records;
+  } finally {
+    if (debug) {
+      console.groupEnd();
+    }
+  }
+};
+var getRecordsByCursorId = async (params) => {
+  const { id, onStep, loadedData = [], debug, guestSpaceId } = params;
+  const response = await api2({
+    endpointName: API_ENDPOINT_CURSOR,
+    method: "GET",
+    body: { id },
+    debug,
+    guestSpaceId
+  });
+  const newRecords = [...loadedData, ...response.records];
+  if (onStep) {
+    onStep({ records: newRecords, incremental: response.records });
+  }
+  return response.next ? getRecordsByCursorId({ ...params, loadedData: newRecords }) : newRecords;
+};
+var updateRecordAssignees = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_ASSIGNEES,
+    method: "PUT",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var updateRecordStatus = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_RECORD_STATUS,
+    method: "PUT",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var updateAllRecordStatuses = async (params) => {
+  const { onProgress, debug, guestSpaceId, ...requestParams } = params;
+  const responses = await bulkRequest({
+    requests: [{ type: "updateRecordStatuses", params: requestParams }],
+    onProgress,
+    debug,
+    guestSpaceId
+  });
+  return responses.results.reduce(
+    (acc, result) => {
+      return {
+        records: [...acc.records, ...result.records]
+      };
+    },
+    { records: [] }
+  );
+};
+var getRecordACLEvaluate = async (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_ACL_EVALUATE,
+    method: "GET",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+var bulkRequest = async (params) => {
+  const { requests, debug, guestSpaceId, limit = API_LIMIT_BULK_REQUEST } = params;
+  if (debug) {
+    console.groupCollapsed("\u{1F4E6} %cbulkRequest", "color: #1e40af");
+  }
+  try {
+    const apiTable = {
+      updateRecord: { endpointName: API_ENDPOINT_RECORD, method: "PUT" },
+      addRecord: { endpointName: API_ENDPOINT_RECORD, method: "POST" },
+      updateAllRecords: { endpointName: API_ENDPOINT_RECORDS, method: "PUT" },
+      addAllRecords: { endpointName: API_ENDPOINT_RECORDS, method: "POST" },
+      deleteRecords: { endpointName: API_ENDPOINT_RECORDS, method: "DELETE" },
+      updateRecordAssignees: { endpointName: API_ENDPOINT_ASSIGNEES, method: "PUT" },
+      updateRecordStatus: { endpointName: API_ENDPOINT_RECORD_STATUS, method: "PUT" },
+      updateRecordStatuses: { endpointName: API_ENDPOINT_RECORD_STATUSES, method: "PUT" }
+    };
+    let reshapedRequests = [];
+    for (const request of requests) {
+      const { endpointName, method } = apiTable[request.type];
+      const api3 = buildPath2({ endpointName, guestSpaceId });
+      if (request.type === "updateRecord" || request.type === "addRecord" || request.type === "updateRecordAssignees" || request.type === "updateRecordStatus") {
+        reshapedRequests.push({ method, api: api3, payload: request.params });
+      } else if (request.type === "updateAllRecords") {
+        const { records: allRecords, ...commonRequestParams } = request.params;
+        const recordChunks = sliceIntoChunks(allRecords, API_LIMIT_PUT);
+        for (const records of recordChunks) {
+          reshapedRequests.push({
+            method,
+            api: api3,
+            payload: { ...commonRequestParams, records }
+          });
+        }
+      } else if (request.type === "addAllRecords") {
+        const recordChunks = sliceIntoChunks(
+          request.params.records,
+          Math.min(request.params.limit ?? API_LIMIT_POST, API_LIMIT_POST)
+        );
+        for (const records of recordChunks) {
+          reshapedRequests.push({ method, api: api3, payload: { ...request.params, records } });
+        }
+      } else if (request.type === "deleteRecords") {
+        const idChunks = sliceIntoChunks(request.params.ids, API_LIMIT_DELETE);
+        for (const ids of idChunks) {
+          reshapedRequests.push({ method, api: api3, payload: { ...request.params, ids } });
+        }
+      } else if (request.type === "updateRecordStatuses") {
+        const recordChunks = sliceIntoChunks(request.params.records, API_LIMIT_PUT);
+        for (const records of recordChunks) {
+          reshapedRequests.push({ method, api: api3, payload: { ...request.params, records } });
+        }
+      }
+    }
+    const responses = [];
+    const requestChunks = sliceIntoChunks(
+      reshapedRequests,
+      Math.min(limit, API_LIMIT_BULK_REQUEST)
+    );
+    let done = 0;
+    for (const requests2 of requestChunks) {
+      const response = await api2({
+        endpointName: API_ENDPOINT_BULK,
+        method: "POST",
+        body: { requests: requests2 },
+        debug,
+        guestSpaceId
+      });
+      if (debug) {
+        done += requests2.length;
+        console.log(
+          `%cbulk request in progress... ${done}/${reshapedRequests.length}`,
+          "color: #999"
+        );
+      }
+      responses.push(response);
+      if (params.onProgress) {
+        params.onProgress({
+          total: reshapedRequests.length,
+          done: responses.reduce((acc, response2) => acc + response2.results.length, 0)
+        });
+      }
+    }
+    return responses.reduce(
+      (acc, response) => {
+        return { results: [...acc.results, ...response.results] };
+      },
+      { results: [] }
+    );
+  } finally {
+    if (debug) {
+      console.groupEnd();
+    }
+  }
+};
+
+// src/rest-api/client.ts
+var useApi = (props) => {
+  return {
+    records: {
+      $post: async (params) => {
+        const { limit = API_LIMIT_POST, ...requestParams } = params;
+        if (requestParams.records.length === 1) {
+          return addRecord({ ...props, record: requestParams.records[0] }).then((res) => ({
+            ids: [res.id],
+            revisions: [res.revision]
+          }));
+        }
+        if (requestParams.records.length <= limit) {
+          return addRecords({ ...props, ...params });
+        }
+        return addAllRecords({ ...props, ...params });
+      }
+    }
+  };
+};
+
+// src/rest-api/file.ts
+var uploadFile = async (params) => {
+  const { file, debug, guestSpaceId } = params;
+  const formData = new FormData();
+  formData.append("__REQUEST_TOKEN__", kintone.getRequestToken());
+  formData.append("file", file.data, file.name);
+  const headers = { "X-Requested-With": "XMLHttpRequest" };
+  const response = await fetch(buildPath2({ endpointName: "file", guestSpaceId }), {
+    method: "POST",
+    headers,
+    body: formData
+  });
+  return response.json();
+};
+var downloadFile = async (params) => {
+  const { fileKey, debug, guestSpaceId } = params;
+  const headers = { "X-Requested-With": "XMLHttpRequest" };
+  const path = buildPath2({ endpointName: "file", guestSpaceId });
+  const response = await fetch(`${path}?fileKey=${fileKey}`, { method: "GET", headers });
+  return response.blob();
+};
+
+// src/rest-api/record-comment.ts
+var API_ENDPOINT_COMMENTS = `record/comments`;
+var API_ENDPOINT_COMMENT = `record/comment`;
+var API_LIMIT_COMMENT = 10;
+var getRecordComments = (props) => {
+  return getRecursiveRecordComments(props);
+};
+var getRecursiveRecordComments = async (requestParams, stored = []) => {
+  const offset = stored.length;
+  const newRequest = {
+    ...requestParams,
+    limit: API_LIMIT_COMMENT,
+    offset
+  };
+  const response = await api2({
+    endpointName: API_ENDPOINT_COMMENTS,
+    method: "GET",
+    body: newRequest,
+    guestSpaceId: requestParams.guestSpaceId
+  });
+  const comments = [...stored, ...response.comments];
+  return response.comments.length === API_LIMIT_COMMENT ? getRecursiveRecordComments(requestParams, comments) : comments;
+};
+var addRecordComment = (params) => {
+  return api2({
+    endpointName: API_ENDPOINT_COMMENT,
+    method: "POST",
+    body: params,
+    guestSpaceId: params.guestSpaceId
+  });
+};
+var deleteRecordComment = (params) => {
+  return api2({
+    endpointName: API_ENDPOINT_COMMENT,
+    method: "DELETE",
+    body: params,
+    guestSpaceId: params.guestSpaceId
+  });
+};
+
+// src/rest-api/report.ts
+var API_ENDPOINT_REPORTS = "app/reports";
+var getAppCharts = (params) => {
+  const { debug, guestSpaceId, ...requestParams } = params;
+  return api2({
+    endpointName: API_ENDPOINT_REPORTS,
+    method: "GET",
+    body: requestParams,
+    debug,
+    guestSpaceId
+  });
+};
+
+// src/rest-api/space.ts
+var API_ENDPOINT_SPACE = "space";
+var API_ENDPOINT_THREAD = "space/thread";
+var API_ENDPOINT_TEMPLATE = "template/space";
+var getSpace = (params) => {
+  return api2({
+    endpointName: API_ENDPOINT_SPACE,
+    method: "GET",
+    body: params,
+    ...params
+  });
+};
+var createSpace = (params) => {
+  const { guestSpaceId, debug, ...body } = params;
+  return api2({
+    endpointName: API_ENDPOINT_TEMPLATE,
+    method: "POST",
+    body,
+    debug,
+    guestSpaceId
+  });
+};
+var deleteSpace = (params) => {
+  const { guestSpaceId, debug, ...body } = params;
+  return api2({
+    endpointName: API_ENDPOINT_SPACE,
+    method: "DELETE",
+    body,
+    debug,
+    guestSpaceId
+  });
+};
+var updateThread = (params) => {
+  const { guestSpaceId, debug, ...body } = params;
+  return api2({
+    endpointName: API_ENDPOINT_THREAD,
+    method: "PUT",
+    body,
+    debug,
+    guestSpaceId
+  });
+};
+
+// src/rest-api/utility.ts
+var filterFieldProperties = (properties, callback) => {
+  const filtered = Object.entries(properties).filter(([_, value]) => callback(value));
+  const reduced = filtered.reduce(
+    (acc, [key, value]) => ({ ...acc, [key]: value }),
+    {}
+  );
+  return reduced;
+};
+var withSpaceIdFallback = async (params) => {
+  const { spaceId, func, funcParams } = params;
+  try {
+    const response = await func(funcParams);
+    return response;
+  } catch (error) {
+    if (["GAIA_IL23", "GAIA_IL25"].includes(error.code)) {
+      const response = await func({ ...funcParams, guestSpaceId: spaceId });
+      return response;
+    }
+    throw error;
+  }
+};
+var isGuestSpace = async (appId) => {
+  try {
+    await getRecords({ app: appId });
+  } catch (error) {
+    return error.code === "GAIA_IL23";
+  }
+  return false;
+};
+var useSorting = (field2, orderBy) => {
+  return ` order by ${String(field2)} ${orderBy}`;
+};
+var useQuery = (conditions, options) => {
+  const { sort, debug = false } = options || {};
+  const mergedCondition = conditions.reduce((acc, condition) => {
+    const { field: field2, operator, value, truth } = condition;
+    const isNumber = !isNaN(Number(value));
+    const formattedValue = !isNumber && !/^("|')/.test(value) ? `"${value}"` : value;
+    if (acc.length) {
+      acc += ` ${truth || "and"} `;
+    }
+    return acc + `${String(field2)} ${operator} ${formattedValue}`;
+  }, "");
+  if (debug) {
+    console.log(`\u{1F50D} Query: ${mergedCondition}`);
+  }
+  if (sort) {
+    return `${mergedCondition}${useSorting(sort.field, sort.orderBy)}`;
+  }
+  return mergedCondition;
+};
+var chunk = (arr, size) => Array.from(
+  { length: Math.ceil(arr.length / size) },
+  (_, i) => arr.slice(i * size, i * size + size)
+);
+
+exports.API_LIMIT_POST = API_LIMIT_POST;
+exports.KintoneEventListener = KintoneEventListener;
+exports.KintoneEventManager = KintoneEventManager;
+exports.PluginLocalStorage = PluginLocalStorage;
+exports.addAllRecords = addAllRecords;
+exports.addRecord = addRecord;
+exports.addRecordComment = addRecordComment;
+exports.addRecords = addRecords;
+exports.backdoor = backdoor;
+exports.backdoorGetRecord = backdoorGetRecord;
+exports.bulkRequest = bulkRequest;
+exports.chunk = chunk;
+exports.compareField = compareField;
+exports.convertFullwidthAlphanumericToHalfwidth = convertFullwidthAlphanumericToHalfwidth;
+exports.convertHalfwidthKatakanaToFullwidth = convertHalfwidthKatakanaToFullwidth;
+exports.convertKatakanaToHiragana = convertKatakanaToHiragana;
+exports.createSpace = createSpace;
+exports.deleteAllRecords = deleteAllRecords;
+exports.deleteAllRecordsByQuery = deleteAllRecordsByQuery;
+exports.deleteRecordComment = deleteRecordComment;
+exports.deleteSpace = deleteSpace;
+exports.detectGuestSpaceId = detectGuestSpaceId;
+exports.downloadFile = downloadFile;
+exports.filterFieldProperties = filterFieldProperties;
+exports.getAllApps = getAllApps;
+exports.getAllRecords = getAllRecords;
+exports.getAllRecordsWithCursor = getAllRecordsWithCursor;
+exports.getAllRecordsWithId = getAllRecordsWithId;
+exports.getApp = getApp;
+exports.getAppCharts = getAppCharts;
+exports.getAppId = getAppId;
+exports.getAppObject = getAppObject;
+exports.getAppSettings = getAppSettings;
+exports.getCalcFieldValueAsString = getCalcFieldValueAsString;
+exports.getCurrentRecord = getCurrentRecord;
+exports.getCybozuGroupUsers = getCybozuGroupUsers;
+exports.getCybozuGroups = getCybozuGroups;
+exports.getCybozuOrganizationUsers = getCybozuOrganizationUsers;
+exports.getCybozuOrganizations = getCybozuOrganizations;
+exports.getCybozuUserGroups = getCybozuUserGroups;
+exports.getCybozuUserOrganizations = getCybozuUserOrganizations;
+exports.getCybozuUsers = getCybozuUsers;
+exports.getDefaultValue = getDefaultValue;
+exports.getEmptyValue = getEmptyValue;
+exports.getFieldElement = getFieldElement;
+exports.getFieldElements = getFieldElements;
+exports.getFieldValueAsString = getFieldValueAsString;
+exports.getFormFields = getFormFields;
+exports.getFormLayout = getFormLayout;
+exports.getHeaderSpace = getHeaderSpace;
+exports.getMetaFieldId_UNSTABLE = getMetaFieldId_UNSTABLE;
+exports.getMetaFields_UNSTABLE = getMetaFields_UNSTABLE;
+exports.getMetaSubtableFields_UNSTABLE = getMetaSubtableFields_UNSTABLE;
+exports.getMetaSubtable_UNSTABLE = getMetaSubtable_UNSTABLE;
+exports.getMetaTable_UNSTABLE = getMetaTable_UNSTABLE;
+exports.getNumberFieldValueAsString = getNumberFieldValueAsString;
+exports.getQuery = getQuery;
+exports.getQueryCondition = getQueryCondition;
+exports.getQueryString_UNSTABLE = getQueryString_UNSTABLE;
+exports.getRecord = getRecord;
+exports.getRecordACLEvaluate = getRecordACLEvaluate;
+exports.getRecordComments = getRecordComments;
+exports.getRecordId = getRecordId;
+exports.getRecords = getRecords;
+exports.getSortFromQuery = getSortFromQuery;
+exports.getSpace = getSpace;
+exports.getSpaceElement = getSpaceElement;
+exports.getViews = getViews;
+exports.getWareki = getWareki;
+exports.getYuruChara = getYuruChara;
+exports.isGuestSpace = isGuestSpace;
+exports.isMobile = isMobile;
+exports.onFileLoad = onFileLoad;
+exports.restorePluginConfig = restorePluginConfig;
+exports.restoreStorage = restoreStorage;
+exports.setCurrentRecord = setCurrentRecord;
+exports.setFieldShown = setFieldShown;
+exports.setPluginProxyConfig = setPluginProxyConfig;
+exports.sortField = sortField;
+exports.storePluginConfig = storePluginConfig;
+exports.storeStorage = storeStorage;
+exports.updateAllRecordStatuses = updateAllRecordStatuses;
+exports.updateAllRecords = updateAllRecords;
+exports.updateRecord = updateRecord;
+exports.updateRecordAssignees = updateRecordAssignees;
+exports.updateRecordStatus = updateRecordStatus;
+exports.updateThread = updateThread;
+exports.updateViews = updateViews;
+exports.uploadFile = uploadFile;
+exports.upsertRecord = upsertRecord;
+exports.useApi = useApi;
+exports.useQuery = useQuery;
+exports.useSorting = useSorting;
+exports.withLogging = withLogging;
+exports.withMobileEvents = withMobileEvents;
+exports.withSpaceIdFallback = withSpaceIdFallback;
+exports.xapp = xapp;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map