@semiont/graph 0.5.9 → 0.5.10

package/dist/chunk-GXSQEW4F.js

@@ -0,0 +1,694 @@
+import {
+  ProtocolLib,
+  SerdeContextConfig,
+  UnionSerde
+} from "./chunk-USQJFUZP.js";
+import {
+  getValueFromTextNode
+} from "./chunk-2UFYZAZA.js";
+import {
+  FromStringShapeDeserializer,
+  NormalizedSchema,
+  RpcProtocol,
+  collectBody,
+  deref,
+  determineTimestampFormat,
+  extendedEncodeURIComponent
+} from "./chunk-7UEKNJE3.js";
+import {
+  NumericValue,
+  dateToUtcString,
+  generateIdempotencyToken,
+  toBase64,
+  toUtf8
+} from "./chunk-DCLCNCC5.js";
+
+// ../../node_modules/@aws-sdk/xml-builder/dist-es/xml-parser.js
+function parseXML(xml) {
+  const state = new AwsXmlParser(xml);
+  return state.parse();
+}
+var AwsXmlParser = class _AwsXmlParser {
+  x;
+  i = 0;
+  z;
+  constructor(x) {
+    this.x = x;
+    this.x = x.replace(/\r\n?/g, "\n");
+    this.z = this.x.length;
+  }
+  parse() {
+    const p = this;
+    const { z } = p;
+    while (p.i < z) {
+      p.trim();
+      if (p.i >= z) {
+        break;
+      }
+      if (p.isNext("<?")) {
+        p.readTo("?>");
+        p.trim();
+      } else if (p.isNext("<!--")) {
+        p.readTo("-->");
+        p.trim();
+      } else if (p.isNext("<!DOCTYPE", false)) {
+        p.skipDoctype();
+        p.trim();
+      } else if (p.x[p.i] === "<") {
+        const root = p.parseTag();
+        return { [root.tag]: root.value };
+      } else {
+        throw new Error("@aws-sdk XML parse error: unexpected content.");
+      }
+    }
+    throw new Error("@aws-sdk XML parse error: no root element.");
+  }
+  isNext(s, caseSensitive = true) {
+    const p = this;
+    if (caseSensitive) {
+      return p.x.startsWith(s, p.i);
+    }
+    return p.x.toLowerCase().startsWith(s.toLowerCase(), p.i);
+  }
+  readTo(stop) {
+    const p = this;
+    const _i = p.x.indexOf(stop, p.i);
+    if (_i === -1) {
+      throw new Error(`@aws-sdk XML parse error: expected "${stop}" not found.`);
+    }
+    const result = p.x.slice(p.i, _i);
+    p.i = _i + stop.length;
+    return result;
+  }
+  trim() {
+    const p = this;
+    while (p.i < p.z && " 	\r\n".includes(p.x[p.i])) {
+      ++p.i;
+    }
+  }
+  readAttrValue() {
+    const p = this;
+    const quote = p.x[p.i];
+    ++p.i;
+    let value = "";
+    while (p.i < p.z && p.x[p.i] !== quote) {
+      value += p.x[p.i++];
+    }
+    ++p.i;
+    return p.decodeEntities(value);
+  }
+  parseTag() {
+    const p = this;
+    ++p.i;
+    let tag = "";
+    while (p.i < p.z && !" 	\r\n>/".includes(p.x[p.i])) {
+      tag += p.x[p.i++];
+    }
+    let hasAttrs = false;
+    const attrs = /* @__PURE__ */ Object.create(null);
+    while (p.i < p.z) {
+      p.trim();
+      if (">/".includes(p.x[p.i])) {
+        break;
+      }
+      let name = "";
+      while (p.i < p.z && !"= 	\r\n>/?".includes(p.x[p.i])) {
+        name += p.x[p.i++];
+      }
+      p.trim();
+      if (p.x[p.i] !== "=") {
+        break;
+      }
+      ++p.i;
+      p.trim();
+      attrs[name] = p.readAttrValue();
+      hasAttrs = true;
+    }
+    if (p.i >= p.z) {
+      throw new Error("@aws-sdk XML parse error: unexpected end of input.");
+    }
+    if (p.x[p.i] === "/") {
+      ++p.i;
+      if (p.i >= p.z || p.x[p.i] !== ">") {
+        throw new Error("@aws-sdk XML parse error: expected > at the end of self-closing tag.");
+      }
+      ++p.i;
+      Object.setPrototypeOf(attrs, Object.prototype);
+      return { tag, value: hasAttrs ? attrs : "" };
+    }
+    if (p.x[p.i] !== ">") {
+      throw new Error("@aws-sdk XML parse error: expected > at the end of opening tag.");
+    }
+    ++p.i;
+    const textParts = [];
+    const childTags = [];
+    let hasElementChild = false;
+    while (p.i < p.z) {
+      if (p.isNext("</")) {
+        break;
+      }
+      if (p.x[p.i] === "<") {
+        if (p.isNext("<!--")) {
+          p.readTo("-->");
+        } else if (p.isNext("<![CDATA[")) {
+          p.i += 9;
+          textParts.push(p.readTo("]]>"));
+        } else if (p.isNext("<?")) {
+          p.readTo("?>");
+        } else {
+          hasElementChild = true;
+          childTags.push(p.parseTag());
+        }
+      } else {
+        let text = "";
+        while (p.i < p.z && p.x[p.i] !== "<") {
+          text += p.x[p.i++];
+        }
+        textParts.push(p.decodeEntities(text));
+      }
+    }
+    if (!p.isNext("</")) {
+      throw new Error(`@aws-sdk XML parse error: missing closing tag </${tag}>.`);
+    }
+    p.i += 2;
+    const closeTag = p.readTo(">").trim();
+    if (closeTag !== tag) {
+      throw new Error(`@aws-sdk XML parse error: mismatched tags <${tag}> and </${closeTag}>.`);
+    }
+    if (!hasAttrs && textParts.length === 0 && !hasElementChild) {
+      return { tag, value: "" };
+    }
+    if (!hasAttrs && !hasElementChild) {
+      const text = textParts.length === 1 ? textParts[0] : textParts.join("");
+      if (text.trim() === "" && text.includes("\n")) {
+        return { tag, value: "" };
+      }
+      return { tag, value: text };
+    }
+    const obj = /* @__PURE__ */ Object.create(null);
+    for (const text of textParts) {
+      if (text.trim() === "" && text.includes("\n")) {
+        continue;
+      }
+      obj["#text"] = "#text" in obj ? obj["#text"] + text : text;
+    }
+    for (const child of childTags) {
+      if (child.tag in obj) {
+        if (Array.isArray(obj[child.tag])) {
+          obj[child.tag].push(child.value);
+        } else {
+          obj[child.tag] = [obj[child.tag], child.value];
+        }
+      } else {
+        obj[child.tag] = child.value;
+      }
+    }
+    for (const [k, v] of Object.entries(attrs)) {
+      obj[k] = v;
+    }
+    Object.setPrototypeOf(obj, Object.prototype);
+    return { tag, value: obj };
+  }
+  static ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'"
+  };
+  skipDoctype() {
+    const p = this;
+    p.i += 9;
+    let depth = 0;
+    while (p.i < p.z) {
+      const c = p.x[p.i];
+      if (c === "[") {
+        ++depth;
+      } else if (c === "]") {
+        --depth;
+      } else if (c === ">" && depth === 0) {
+        ++p.i;
+        return;
+      }
+      ++p.i;
+    }
+    throw new Error("@aws-sdk XML parse error: unclosed DOCTYPE.");
+  }
+  decodeEntities(s) {
+    return s.replace(/&(?:#x([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{0,30}));/g, (_, hex, dec, named) => {
+      if (hex) {
+        return String.fromCharCode(parseInt(hex, 16));
+      }
+      if (dec) {
+        return String.fromCharCode(parseInt(dec, 10));
+      }
+      return _AwsXmlParser.ENTITIES[named] ?? "";
+    });
+  }
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/XmlShapeDeserializer.js
+var XmlShapeDeserializer = class extends SerdeContextConfig {
+  settings;
+  stringDeserializer;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+    this.stringDeserializer = new FromStringShapeDeserializer(settings);
+  }
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+    this.stringDeserializer.setSerdeContext(serdeContext);
+  }
+  read(schema, bytes, key) {
+    const ns = NormalizedSchema.of(schema);
+    const memberSchemas = ns.getMemberSchemas();
+    const isEventPayload = ns.isStructSchema() && ns.isMemberSchema() && !!Object.values(memberSchemas).find((memberNs) => {
+      return !!memberNs.getMemberTraits().eventPayload;
+    });
+    if (isEventPayload) {
+      const output = {};
+      const memberName = Object.keys(memberSchemas)[0];
+      const eventMemberSchema = memberSchemas[memberName];
+      if (eventMemberSchema.isBlobSchema()) {
+        output[memberName] = bytes;
+      } else {
+        output[memberName] = this.read(memberSchemas[memberName], bytes);
+      }
+      return output;
+    }
+    const xmlString = (this.serdeContext?.utf8Encoder ?? toUtf8)(bytes);
+    const parsedObject = this.parseXml(xmlString);
+    return this.readSchema(schema, key ? parsedObject[key] : parsedObject);
+  }
+  readSchema(_schema, value) {
+    const ns = NormalizedSchema.of(_schema);
+    if (ns.isUnitSchema()) {
+      return;
+    }
+    const traits = ns.getMergedTraits();
+    if (ns.isListSchema() && !Array.isArray(value)) {
+      return this.readSchema(ns, [value]);
+    }
+    if (value == null) {
+      return value;
+    }
+    if (typeof value === "object") {
+      const flat = !!traits.xmlFlattened;
+      if (ns.isListSchema()) {
+        const listValue = ns.getValueSchema();
+        const buffer2 = [];
+        const sourceKey = listValue.getMergedTraits().xmlName ?? "member";
+        const source = flat ? value : (value[0] ?? value)[sourceKey];
+        if (source == null) {
+          return buffer2;
+        }
+        const sourceArray = Array.isArray(source) ? source : [source];
+        for (const v of sourceArray) {
+          buffer2.push(this.readSchema(listValue, v));
+        }
+        return buffer2;
+      }
+      const buffer = {};
+      if (ns.isMapSchema()) {
+        const keyNs = ns.getKeySchema();
+        const memberNs = ns.getValueSchema();
+        let entries;
+        if (flat) {
+          entries = Array.isArray(value) ? value : [value];
+        } else {
+          entries = Array.isArray(value.entry) ? value.entry : [value.entry];
+        }
+        const keyProperty = keyNs.getMergedTraits().xmlName ?? "key";
+        const valueProperty = memberNs.getMergedTraits().xmlName ?? "value";
+        for (const entry of entries) {
+          const key = entry[keyProperty];
+          const value2 = entry[valueProperty];
+          buffer[key] = this.readSchema(memberNs, value2);
+        }
+        return buffer;
+      }
+      if (ns.isStructSchema()) {
+        const union = ns.isUnionSchema();
+        let unionSerde;
+        if (union) {
+          unionSerde = new UnionSerde(value, buffer);
+        }
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+          const memberTraits = memberSchema.getMergedTraits();
+          const xmlObjectKey = !memberTraits.httpPayload ? memberSchema.getMemberTraits().xmlName ?? memberName : memberTraits.xmlName ?? memberSchema.getName();
+          if (union) {
+            unionSerde.mark(xmlObjectKey);
+          }
+          if (value[xmlObjectKey] != null) {
+            buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]);
+          }
+        }
+        if (union) {
+          unionSerde.writeUnknown();
+        }
+        return buffer;
+      }
+      if (ns.isDocumentSchema()) {
+        return value;
+      }
+      throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`);
+    }
+    if (ns.isListSchema()) {
+      return [];
+    }
+    if (ns.isMapSchema() || ns.isStructSchema()) {
+      return {};
+    }
+    return this.stringDeserializer.read(ns, value);
+  }
+  parseXml(xml) {
+    if (xml.length) {
+      let parsedObj;
+      try {
+        parsedObj = parseXML(xml);
+      } catch (e) {
+        if (e && typeof e === "object") {
+          Object.defineProperty(e, "$responseBodyText", {
+            value: xml
+          });
+        }
+        throw e;
+      }
+      const textNodeName = "#text";
+      const key = Object.keys(parsedObj)[0];
+      const parsedObjToReturn = parsedObj[key];
+      if (parsedObjToReturn[textNodeName]) {
+        parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+        delete parsedObjToReturn[textNodeName];
+      }
+      return getValueFromTextNode(parsedObjToReturn);
+    }
+    return {};
+  }
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/QueryShapeSerializer.js
+var QueryShapeSerializer = class extends SerdeContextConfig {
+  settings;
+  buffer;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  write(schema, value, prefix = "") {
+    if (this.buffer === void 0) {
+      this.buffer = "";
+    }
+    const ns = NormalizedSchema.of(schema);
+    if (prefix && !prefix.endsWith(".")) {
+      prefix += ".";
+    }
+    if (ns.isBlobSchema()) {
+      if (typeof value === "string" || value instanceof Uint8Array) {
+        this.writeKey(prefix);
+        this.writeValue((this.serdeContext?.base64Encoder ?? toBase64)(value));
+      }
+    } else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) {
+      if (value != null) {
+        this.writeKey(prefix);
+        this.writeValue(String(value));
+      } else if (ns.isIdempotencyToken()) {
+        this.writeKey(prefix);
+        this.writeValue(generateIdempotencyToken());
+      }
+    } else if (ns.isBigIntegerSchema()) {
+      if (value != null) {
+        this.writeKey(prefix);
+        this.writeValue(String(value));
+      }
+    } else if (ns.isBigDecimalSchema()) {
+      if (value != null) {
+        this.writeKey(prefix);
+        this.writeValue(value instanceof NumericValue ? value.string : String(value));
+      }
+    } else if (ns.isTimestampSchema()) {
+      if (value instanceof Date) {
+        this.writeKey(prefix);
+        const format = determineTimestampFormat(ns, this.settings);
+        switch (format) {
+          case 5:
+            this.writeValue(value.toISOString().replace(".000Z", "Z"));
+            break;
+          case 6:
+            this.writeValue(dateToUtcString(value));
+            break;
+          case 7:
+            this.writeValue(String(value.getTime() / 1e3));
+            break;
+        }
+      }
+    } else if (ns.isDocumentSchema()) {
+      if (Array.isArray(value)) {
+        this.write(64 | 15, value, prefix);
+      } else if (value instanceof Date) {
+        this.write(4, value, prefix);
+      } else if (value instanceof Uint8Array) {
+        this.write(21, value, prefix);
+      } else if (value && typeof value === "object") {
+        this.write(128 | 15, value, prefix);
+      } else {
+        this.writeKey(prefix);
+        this.writeValue(String(value));
+      }
+    } else if (ns.isListSchema()) {
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          if (this.settings.serializeEmptyLists) {
+            this.writeKey(prefix);
+            this.writeValue("");
+          }
+        } else {
+          const member = ns.getValueSchema();
+          const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened;
+          let i = 1;
+          for (const item of value) {
+            if (item == null) {
+              continue;
+            }
+            const traits = member.getMergedTraits();
+            const suffix = this.getKey("member", traits.xmlName, traits.ec2QueryName);
+            const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`;
+            this.write(member, item, key);
+            ++i;
+          }
+        }
+      }
+    } else if (ns.isMapSchema()) {
+      if (value && typeof value === "object") {
+        const keySchema = ns.getKeySchema();
+        const memberSchema = ns.getValueSchema();
+        const flat = ns.getMergedTraits().xmlFlattened;
+        let i = 1;
+        for (const k in value) {
+          const v = value[k];
+          if (v == null) {
+            continue;
+          }
+          const keyTraits = keySchema.getMergedTraits();
+          const keySuffix = this.getKey("key", keyTraits.xmlName, keyTraits.ec2QueryName);
+          const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`;
+          const valTraits = memberSchema.getMergedTraits();
+          const valueSuffix = this.getKey("value", valTraits.xmlName, valTraits.ec2QueryName);
+          const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`;
+          this.write(keySchema, k, key);
+          this.write(memberSchema, v, valueKey);
+          ++i;
+        }
+      }
+    } else if (ns.isStructSchema()) {
+      if (value && typeof value === "object") {
+        let didWriteMember = false;
+        for (const [memberName, member] of ns.structIterator()) {
+          if (value[memberName] == null && !member.isIdempotencyToken()) {
+            continue;
+          }
+          const traits = member.getMergedTraits();
+          const suffix = this.getKey(memberName, traits.xmlName, traits.ec2QueryName, "struct");
+          const key = `${prefix}${suffix}`;
+          this.write(member, value[memberName], key);
+          didWriteMember = true;
+        }
+        if (!didWriteMember && ns.isUnionSchema()) {
+          const { $unknown } = value;
+          if (Array.isArray($unknown)) {
+            const [k, v] = $unknown;
+            const key = `${prefix}${k}`;
+            this.write(15, v, key);
+          }
+        }
+      }
+    } else if (ns.isUnitSchema()) {
+    } else {
+      throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`);
+    }
+  }
+  flush() {
+    if (this.buffer === void 0) {
+      throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer.");
+    }
+    const str = this.buffer;
+    delete this.buffer;
+    return str;
+  }
+  getKey(memberName, xmlName, ec2QueryName, keySource) {
+    const { ec2, capitalizeKeys } = this.settings;
+    if (ec2 && ec2QueryName) {
+      return ec2QueryName;
+    }
+    const key = xmlName ?? memberName;
+    if (capitalizeKeys && keySource === "struct") {
+      return key[0].toUpperCase() + key.slice(1);
+    }
+    return key;
+  }
+  writeKey(key) {
+    if (key.endsWith(".")) {
+      key = key.slice(0, key.length - 1);
+    }
+    this.buffer += `&${extendedEncodeURIComponent(key)}=`;
+  }
+  writeValue(value) {
+    this.buffer += extendedEncodeURIComponent(value);
+  }
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/AwsQueryProtocol.js
+var AwsQueryProtocol = class extends RpcProtocol {
+  options;
+  serializer;
+  deserializer;
+  mixin = new ProtocolLib();
+  constructor(options) {
+    super({
+      defaultNamespace: options.defaultNamespace,
+      errorTypeRegistries: options.errorTypeRegistries
+    });
+    this.options = options;
+    const settings = {
+      timestampFormat: {
+        useTrait: true,
+        default: 5
+      },
+      httpBindings: false,
+      xmlNamespace: options.xmlNamespace,
+      serviceNamespace: options.defaultNamespace,
+      serializeEmptyLists: true
+    };
+    this.serializer = new QueryShapeSerializer(settings);
+    this.deserializer = new XmlShapeDeserializer(settings);
+  }
+  getShapeId() {
+    return "aws.protocols#awsQuery";
+  }
+  setSerdeContext(serdeContext) {
+    this.serializer.setSerdeContext(serdeContext);
+    this.deserializer.setSerdeContext(serdeContext);
+  }
+  getPayloadCodec() {
+    throw new Error("AWSQuery protocol has no payload codec.");
+  }
+  async serializeRequest(operationSchema, input, context) {
+    const request = await super.serializeRequest(operationSchema, input, context);
+    if (!request.path.endsWith("/")) {
+      request.path += "/";
+    }
+    request.headers["content-type"] = "application/x-www-form-urlencoded";
+    if (deref(operationSchema.input) === "unit" || !request.body) {
+      request.body = "";
+    }
+    const action = operationSchema.name.split("#")[1] ?? operationSchema.name;
+    request.body = `Action=${action}&Version=${this.options.version}` + request.body;
+    if (request.body.endsWith("&")) {
+      request.body = request.body.slice(-1);
+    }
+    return request;
+  }
+  async deserializeResponse(operationSchema, context, response) {
+    const deserializer = this.deserializer;
+    const ns = NormalizedSchema.of(operationSchema.output);
+    const dataObject = {};
+    if (response.statusCode >= 300) {
+      const bytes2 = await collectBody(response.body, context);
+      if (bytes2.byteLength > 0) {
+        Object.assign(dataObject, await deserializer.read(15, bytes2));
+      }
+      await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+    }
+    for (const header in response.headers) {
+      const value = response.headers[header];
+      delete response.headers[header];
+      response.headers[header.toLowerCase()] = value;
+    }
+    const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name;
+    const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : void 0;
+    const bytes = await collectBody(response.body, context);
+    if (bytes.byteLength > 0) {
+      Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey));
+    }
+    dataObject.$metadata = this.deserializeMetadata(response);
+    return dataObject;
+  }
+  useNestedResult() {
+    return true;
+  }
+  async handleError(operationSchema, context, response, dataObject, metadata) {
+    const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
+    this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
+    const errorData = this.loadQueryError(dataObject) ?? {};
+    const message = this.loadQueryErrorMessage(dataObject);
+    errorData.message = message;
+    errorData.Error = {
+      Type: errorData.Type,
+      Code: errorData.Code,
+      Message: message
+    };
+    const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, this.mixin.findQueryCompatibleError);
+    const ns = NormalizedSchema.of(errorSchema);
+    const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
+    const exception = new ErrorCtor({});
+    const output = {
+      Type: errorData.Error.Type,
+      Code: errorData.Error.Code,
+      Error: errorData.Error
+    };
+    for (const [name, member] of ns.structIterator()) {
+      const target = member.getMergedTraits().xmlName ?? name;
+      const value = errorData[target] ?? dataObject[target];
+      output[name] = this.deserializer.readSchema(member, value);
+    }
+    throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
+      $fault: ns.getMergedTraits().error,
+      message
+    }, output), dataObject);
+  }
+  loadQueryErrorCode(output, data) {
+    const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code;
+    if (code !== void 0) {
+      return code;
+    }
+    if (output.statusCode == 404) {
+      return "NotFound";
+    }
+  }
+  loadQueryError(data) {
+    return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error;
+  }
+  loadQueryErrorMessage(data) {
+    const errorData = this.loadQueryError(data);
+    return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown";
+  }
+  getDefaultContentType() {
+    return "application/x-www-form-urlencoded";
+  }
+};
+
+export {
+  AwsQueryProtocol
+};
+//# sourceMappingURL=chunk-GXSQEW4F.js.map