@rebasepro/schema-inference 0.0.1-canary.09e5ec5

package/LICENSE

@@ -0,0 +1,114 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             Rebase S.L.
+Licensed Work:        Rebase CMS packages:
+                      cli
+                      collection_editor
+                      collection_editor_firebase
+                      data_enhancement
+                      data_export
+                      data_export
+                      editor
+                      rebase_cloud
+                      schema_inference
+                      user_management
+
+                      The Licensed Work is (c) 2024 Rebase S.L
+Additional Use Grant: You may make use of the Licensed Work, provided that
+                      you may not use the Licensed Work for a CMS Data Enhancement
+                      Service.
+
+                      A “CMS package” is a commercial offering that
+                      allows third parties (other than your employees and
+                      contractors) to access the functionality of the
+                      Licensed Work by using software to extend the base features of
+                      content management system controlled by such third parties.
+
+Change Date:         Four years from the date the Licensed Work is published.
+
+Change License:      MIT
+
+For information about alternative licensing arrangements for the Software,
+please visit: https://rebase.pro
+
+Notice
+
+The Business Source License (this document, or the “License”) is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+“Business Source License” is a trademark of MariaDB Corporation Ab.
+
+-----------------------------------------------------------------------------
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license
+your works, and to refer to it using the trademark “Business Source License”,
+as long as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the “Business
+Source License” name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where “compatible” means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text “None”.
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.

package/README.md

@@ -0,0 +1 @@
+# schema_inference

package/dist/builders/reference_property_builder.d.ts

@@ -0,0 +1,3 @@
+import { InferencePropertyBuilderProps } from "../types";
+import { Property } from "@rebasepro/types";
+export declare function buildReferenceProperty({ name, totalDocsCount, valuesResult }: InferencePropertyBuilderProps): Property;

package/dist/builders/string_property_builder.d.ts

@@ -0,0 +1,3 @@
+import { Property } from "@rebasepro/types";
+import { InferencePropertyBuilderProps } from "../types";
+export declare function buildStringProperty({ name, totalDocsCount, valuesResult }: InferencePropertyBuilderProps): Property;

package/dist/builders/validation_builder.d.ts

@@ -0,0 +1,3 @@
+import { PropertyValidationSchema } from "@rebasepro/types";
+import { InferencePropertyBuilderProps } from "../types";
+export declare function buildValidation({ totalDocsCount, valuesResult }: InferencePropertyBuilderProps): PropertyValidationSchema | undefined;

package/dist/collection_builder.d.ts

@@ -0,0 +1,6 @@
+import { DataType, Properties, Property } from "@rebasepro/types";
+export type InferenceTypeBuilder = (value: any) => DataType;
+export declare function buildEntityPropertiesFromData(data: object[], getType: InferenceTypeBuilder): Promise<Properties>;
+export declare function buildPropertyFromData(data: any[], property: Property, getType: InferenceTypeBuilder): Property;
+export declare function buildPropertiesOrder(properties: Properties, propertiesOrder?: string[], priorityKeys?: string[]): string[];
+export declare function inferTypeFromValue(value: any): DataType;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./collection_builder";
+export * from "./util";
+export * from "./strings";

package/dist/index.es.js

@@ -0,0 +1,523 @@
+import { unslugify, mergeDeep, prettifyIdentifier } from "@rebasepro/utils";
+import { isObject, isPlainObject, mergeDeep as mergeDeep2, prettifyIdentifier as prettifyIdentifier2, unslugify as unslugify2 } from "@rebasepro/utils";
+function parseReferenceString(value) {
+  if (!value) return null;
+  let database = void 0;
+  let fullPath = value;
+  if (value.includes(":::")) {
+    const [dbName, pathPart] = value.split(":::");
+    if (dbName && dbName !== "(default)") {
+      database = dbName;
+    }
+    fullPath = pathPart;
+  }
+  if (!fullPath || !fullPath.includes("/")) {
+    return null;
+  }
+  const path = fullPath.substring(0, fullPath.lastIndexOf("/"));
+  return {
+    path,
+    database
+  };
+}
+function looksLikeReference(value) {
+  if (typeof value !== "string") return false;
+  return parseReferenceString(value) !== null;
+}
+function findCommonInitialStringInPath(valuesCount) {
+  if (!valuesCount) return void 0;
+  function getPath(value) {
+    let pathString;
+    if (typeof value === "string") {
+      pathString = value;
+    } else if (value.slug) {
+      pathString = value.slug;
+    } else {
+      console.warn("findCommonInitialStringInPath: value is not a string or document with path", value);
+      return void 0;
+    }
+    if (!pathString) return void 0;
+    if (pathString.includes(":::")) {
+      const [, pathPart] = pathString.split(":::");
+      pathString = pathPart;
+    }
+    return pathString;
+  }
+  const strings = valuesCount.values.map((v) => getPath(v)).filter((v) => !!v);
+  const pathWithSlash = strings.find((s) => s.includes("/"));
+  if (!pathWithSlash)
+    return void 0;
+  const searchedPath = pathWithSlash.substring(0, pathWithSlash.lastIndexOf("/"));
+  const yep = valuesCount.values.filter((value) => {
+    const path = getPath(value);
+    if (!path) return false;
+    return path.startsWith(searchedPath);
+  }).length > valuesCount.values.length / 3 * 2;
+  return yep ? searchedPath : void 0;
+}
+function removeInitialAndTrailingSlashes(s) {
+  return removeInitialSlash(removeTrailingSlash(s));
+}
+function removeInitialSlash(s) {
+  if (s.startsWith("/"))
+    return s.slice(1);
+  else return s;
+}
+function removeTrailingSlash(s) {
+  if (s.endsWith("/"))
+    return s.slice(0, -1);
+  else return s;
+}
+function extractEnumFromValues(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const enumValues = values.map((value) => {
+    if (typeof value === "string") {
+      return {
+        id: value,
+        label: unslugify(value)
+      };
+    } else
+      return null;
+  }).filter(Boolean);
+  enumValues.sort((a, b) => a.label.localeCompare(b.label));
+  return enumValues;
+}
+function resolveEnumValues(input) {
+  if (Array.isArray(input)) {
+    return input;
+  } else if (typeof input === "object" && input !== null) {
+    return Object.entries(input).map(([id, value]) => typeof value === "string" ? {
+      id,
+      label: value
+    } : value);
+  } else {
+    return void 0;
+  }
+}
+const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".webp", ".gif", ".avif"];
+const AUDIO_EXTENSIONS = [".mp3", ".ogg", ".opus", ".aac"];
+const VIDEO_EXTENSIONS = [".avi", ".mp4"];
+const emailRegEx = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+function buildStringProperty({
+  name,
+  totalDocsCount,
+  valuesResult
+}) {
+  let stringProperty = {
+    name: name ?? "",
+    type: "string"
+  };
+  if (valuesResult) {
+    const totalEntriesCount = valuesResult.values.length;
+    const totalValues = Array.from(valuesResult.valuesCount.keys()).length;
+    const config = {};
+    const probablyAURL = valuesResult.values.filter((value) => typeof value === "string" && value.toString().startsWith("http")).length > totalDocsCount / 3 * 2;
+    if (probablyAURL) {
+      config.url = true;
+    }
+    const probablyAnEmail = valuesResult.values.filter((value) => typeof value === "string" && emailRegEx.test(value)).length > totalDocsCount / 3 * 2;
+    if (probablyAnEmail) {
+      config.email = true;
+    }
+    const probablyUserIds = valuesResult.values.filter((value) => typeof value === "string" && value.length === 28 && !value.includes(" ")).length > totalDocsCount / 3 * 2;
+    if (probablyUserIds)
+      config.readOnly = true;
+    if (!probablyAnEmail && !probablyAURL && !probablyUserIds && !probablyAURL && totalValues < totalEntriesCount / 3) {
+      const enumValues = extractEnumFromValues(Array.from(valuesResult.valuesCount.keys()));
+      if (Object.keys(enumValues).length > 1)
+        config.enum = enumValues;
+    }
+    if (!probablyAnEmail && !probablyAURL && !probablyUserIds && !probablyAURL && !config.enum) {
+      const fileType = probableFileType(valuesResult, totalDocsCount);
+      if (fileType) {
+        config.storage = {
+          acceptedFiles: fileType,
+          storagePath: findCommonInitialStringInPath(valuesResult) ?? "/"
+        };
+      }
+    }
+    if (Object.keys(config).length > 0)
+      stringProperty = {
+        ...stringProperty,
+        ...config
+      };
+  }
+  return stringProperty;
+}
+function probableFileType(valuesCount, totalDocsCount) {
+  const isImage = (value) => IMAGE_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
+  const isAudio = (value) => AUDIO_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
+  const isVideo = (value) => VIDEO_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
+  const stringValues = valuesCount.values.filter((v) => typeof v === "string");
+  let imageCount = 0;
+  let audioCount = 0;
+  let videoCount = 0;
+  for (const value of stringValues) {
+    if (isImage(value)) imageCount++;
+    else if (isAudio(value)) audioCount++;
+    else if (isVideo(value)) videoCount++;
+  }
+  const totalMediaCount = imageCount + audioCount + videoCount;
+  if (totalMediaCount > totalDocsCount * 2 / 3) {
+    const fileTypes = [];
+    if (imageCount > 0) fileTypes.push("image/*");
+    if (audioCount > 0) fileTypes.push("audio/*");
+    if (videoCount > 0) fileTypes.push("video/*");
+    return fileTypes.length > 0 ? fileTypes : false;
+  }
+  return false;
+}
+function buildValidation({
+  totalDocsCount,
+  valuesResult
+}) {
+  if (valuesResult) {
+    const totalEntriesCount = valuesResult.values.length;
+    if (totalDocsCount === totalEntriesCount)
+      return {
+        required: true
+      };
+  }
+  return void 0;
+}
+function buildReferenceProperty({
+  name,
+  totalDocsCount,
+  valuesResult
+}) {
+  const property = {
+    name: name ?? "",
+    type: "reference",
+    path: findCommonInitialStringInPath(valuesResult) ?? "!!!FIX_ME!!!"
+  };
+  return property;
+}
+async function buildEntityPropertiesFromData(data, getType) {
+  const typesCount = {};
+  const valuesCount = {};
+  if (data) {
+    data.forEach((entry) => {
+      if (entry) {
+        Object.entries(entry).forEach(([key, value]) => {
+          if (key.startsWith("_")) return;
+          increaseMapTypeCount(typesCount, key, value, getType);
+          increaseValuesCount(valuesCount, key, value, getType);
+        });
+      }
+    });
+  }
+  return buildPropertiesFromCount(data.length, typesCount, valuesCount);
+}
+function buildPropertyFromData(data, property, getType) {
+  const typesCount = {};
+  const valuesCount = {};
+  if (data) {
+    data.forEach((entry) => {
+      increaseTypeCount(property.type, typesCount, entry, getType);
+      increaseValuesCount(valuesCount, "inferred_prop", entry, getType);
+    });
+  }
+  const enumValues = "enum" in property ? resolveEnumValues(property["enum"]) : void 0;
+  if (enumValues) {
+    const newEnumValues = extractEnumFromValues(Array.from(valuesCount["inferred_prop"].valuesCount.keys()));
+    return {
+      ...property,
+      enum: [...newEnumValues, ...enumValues]
+    };
+  }
+  const generatedProperty = buildPropertyFromCount(
+    "inferred_prop",
+    data.length,
+    property.type,
+    typesCount,
+    valuesCount["inferred_prop"]
+  );
+  return mergeDeep(generatedProperty, property);
+}
+function buildPropertiesOrder(properties, propertiesOrder, priorityKeys) {
+  const lowerCasePriorityKeys = (priorityKeys ?? []).map((key) => key.toLowerCase());
+  function propOrder(s) {
+    const k = s.toLowerCase();
+    if (lowerCasePriorityKeys.includes(k)) return 4;
+    if (k === "title" || k === "name") return 3;
+    if (k.includes("title") || k.includes("name")) return 2;
+    if (k.includes("image") || k.includes("picture")) return 1;
+    return 0;
+  }
+  const keys = propertiesOrder ?? Object.keys(properties);
+  keys.sort();
+  keys.sort((a, b) => {
+    return propOrder(b) - propOrder(a);
+  });
+  return keys;
+}
+function increaseTypeCount(type, typesCount, fieldValue, getType) {
+  if (type === "map") {
+    if (fieldValue) {
+      let mapTypesCount = typesCount[type];
+      if (!mapTypesCount) {
+        mapTypesCount = {};
+        typesCount[type] = mapTypesCount;
+      }
+      Object.entries(fieldValue).forEach(([key, value]) => {
+        increaseMapTypeCount(mapTypesCount, key, value, getType);
+      });
+    }
+  } else if (type === "array") {
+    let arrayTypesCount = typesCount[type];
+    if (!arrayTypesCount) {
+      arrayTypesCount = {};
+      typesCount[type] = arrayTypesCount;
+    }
+    if (fieldValue && Array.isArray(fieldValue) && fieldValue.length > 0) {
+      const arrayType = getMostProbableTypeInArray(fieldValue, getType);
+      if (arrayType === "map") {
+        let mapTypesCount = arrayTypesCount[arrayType];
+        if (!mapTypesCount) {
+          mapTypesCount = {};
+        }
+        fieldValue.forEach((value) => {
+          if (value && typeof value === "object" && !Array.isArray(value)) {
+            Object.entries(value).forEach(
+              ([key, v]) => increaseMapTypeCount(mapTypesCount, key, v, getType)
+            );
+          }
+        });
+        arrayTypesCount[arrayType] = mapTypesCount;
+      } else {
+        if (!arrayTypesCount[arrayType]) arrayTypesCount[arrayType] = 1;
+        else arrayTypesCount[arrayType] = Number(arrayTypesCount[arrayType]) + 1;
+      }
+    }
+  } else {
+    if (!typesCount[type]) typesCount[type] = 1;
+    else typesCount[type] = Number(typesCount[type]) + 1;
+  }
+}
+function increaseMapTypeCount(typesCountRecord, key, fieldValue, getType) {
+  if (key.startsWith("_")) return;
+  let typesCount = typesCountRecord[key];
+  if (!typesCount) {
+    typesCount = {};
+    typesCountRecord[key] = typesCount;
+  }
+  if (fieldValue != null) {
+    const type = getType(fieldValue);
+    increaseTypeCount(type, typesCount, fieldValue, getType);
+  }
+}
+function increaseValuesCount(typeValuesRecord, key, fieldValue, getType) {
+  if (key.startsWith("_")) return;
+  const type = getType(fieldValue);
+  let valuesRecord = typeValuesRecord[key];
+  if (!valuesRecord) {
+    valuesRecord = {
+      values: [],
+      valuesCount: /* @__PURE__ */ new Map()
+    };
+    typeValuesRecord[key] = valuesRecord;
+  }
+  if (type === "map") {
+    let mapValuesRecord = valuesRecord.map;
+    if (!mapValuesRecord) {
+      mapValuesRecord = {};
+      valuesRecord.map = mapValuesRecord;
+    }
+    if (fieldValue)
+      Object.entries(fieldValue).forEach(
+        ([subKey, value]) => increaseValuesCount(mapValuesRecord, subKey, value, getType)
+      );
+  } else if (type === "array") {
+    if (Array.isArray(fieldValue)) {
+      fieldValue.forEach((value) => {
+        valuesRecord.values.push(value);
+        valuesRecord.valuesCount.set(value, (valuesRecord.valuesCount.get(value) ?? 0) + 1);
+      });
+    }
+  } else {
+    if (fieldValue !== null && fieldValue !== void 0) {
+      valuesRecord.values.push(fieldValue);
+      valuesRecord.valuesCount.set(fieldValue, (valuesRecord.valuesCount.get(fieldValue) ?? 0) + 1);
+    }
+  }
+}
+function getHighestTypesCount(typesCount) {
+  let highestCount = 0;
+  Object.entries(typesCount).forEach(([type, count]) => {
+    let countValue = 0;
+    if (type === "map") {
+      countValue = getHighestRecordCount(count);
+    } else if (type === "array") {
+      countValue = getHighestTypesCount(count);
+    } else {
+      countValue = Number(count);
+    }
+    if (countValue > highestCount) {
+      highestCount = countValue;
+    }
+  });
+  return highestCount;
+}
+function getHighestRecordCount(record) {
+  return Object.entries(record).map(([key, typesCount]) => getHighestTypesCount(typesCount)).reduce((a, b) => Math.max(a, b), 0);
+}
+function getMostProbableType(typesCount) {
+  let highestCount = -1;
+  let probableType = "string";
+  Object.entries(typesCount).forEach(([type, count]) => {
+    let countValue;
+    if (type === "map") {
+      countValue = getHighestRecordCount(count);
+    } else if (type === "array") {
+      countValue = getHighestTypesCount(count);
+    } else {
+      countValue = Number(count);
+    }
+    if (countValue > highestCount) {
+      highestCount = countValue;
+      probableType = type;
+    }
+  });
+  return probableType;
+}
+function buildPropertyFromCount(key, totalDocsCount, mostProbableType, typesCount, valuesResult) {
+  let title;
+  if (key) {
+    title = prettifyIdentifier(key);
+  }
+  let result = void 0;
+  if (mostProbableType === "map") {
+    const highVariability = checkTypesCountHighVariability(typesCount);
+    if (highVariability) {
+      result = {
+        type: "map",
+        name: title ?? key ?? "",
+        keyValue: true,
+        properties: {}
+      };
+    }
+    const properties = buildPropertiesFromCount(
+      totalDocsCount,
+      typesCount.map,
+      valuesResult ? valuesResult.mapValues : void 0
+    );
+    result = {
+      type: "map",
+      name: title ?? key ?? "",
+      properties
+    };
+  } else if (mostProbableType === "array") {
+    const arrayTypesCount = typesCount.array;
+    const arrayMostProbableType = getMostProbableType(arrayTypesCount);
+    const of = buildPropertyFromCount(
+      key,
+      totalDocsCount,
+      arrayMostProbableType,
+      arrayTypesCount,
+      valuesResult
+    );
+    result = {
+      type: "array",
+      name: title ?? key ?? "",
+      of
+    };
+  }
+  if (!result) {
+    const propertyProps = {
+      name: key,
+      totalDocsCount,
+      valuesResult
+    };
+    if (mostProbableType === "string") {
+      result = buildStringProperty(propertyProps);
+    } else if (mostProbableType === "reference") {
+      result = buildReferenceProperty(propertyProps);
+    } else {
+      result = {
+        type: mostProbableType
+      };
+    }
+    if (title) {
+      result.name = title;
+    }
+    const validation = buildValidation(propertyProps);
+    if (validation) {
+      result.validation = validation;
+    }
+  }
+  return result;
+}
+function buildPropertiesFromCount(totalDocsCount, typesCountRecord, valuesCountRecord) {
+  const res = {};
+  Object.entries(typesCountRecord).forEach(([key, typesCount]) => {
+    const mostProbableType = getMostProbableType(typesCount);
+    res[key] = buildPropertyFromCount(
+      key,
+      totalDocsCount,
+      mostProbableType,
+      typesCount,
+      valuesCountRecord ? valuesCountRecord[key] : void 0
+    );
+  });
+  return res;
+}
+function countMaxDocumentsUnder(typesCount) {
+  let count = 0;
+  Object.entries(typesCount).forEach(([type, value]) => {
+    if (typeof value === "object") {
+      count = Math.max(count, countMaxDocumentsUnder(value));
+    } else {
+      count = Math.max(count, Number(value));
+    }
+  });
+  return count;
+}
+function getMostProbableTypeInArray(array, getType) {
+  const typesCount = {};
+  array.forEach((value) => {
+    increaseTypeCount(getType(value), typesCount, value, getType);
+  });
+  return getMostProbableType(typesCount);
+}
+function checkTypesCountHighVariability(typesCount) {
+  const maxCount = countMaxDocumentsUnder(typesCount);
+  let keysWithFewValues = 0;
+  Object.entries(typesCount.map ?? {}).forEach(([key, value]) => {
+    const count = countMaxDocumentsUnder(value);
+    if (count < maxCount / 3) {
+      keysWithFewValues++;
+    }
+  });
+  return keysWithFewValues / Object.entries(typesCount.map ?? {}).length > 0.5;
+}
+function inferTypeFromValue(value) {
+  if (value === null || value === void 0) return "string";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "object") return "map";
+  return "string";
+}
+export {
+  buildEntityPropertiesFromData,
+  buildPropertiesOrder,
+  buildPropertyFromData,
+  extractEnumFromValues,
+  findCommonInitialStringInPath,
+  inferTypeFromValue,
+  isObject,
+  isPlainObject,
+  looksLikeReference,
+  mergeDeep2 as mergeDeep,
+  parseReferenceString,
+  prettifyIdentifier2 as prettifyIdentifier,
+  removeInitialAndTrailingSlashes,
+  removeInitialSlash,
+  removeTrailingSlash,
+  resolveEnumValues,
+  unslugify2 as unslugify
+};
+//# sourceMappingURL=index.es.js.map