eco-vue-js 0.3.67

package/dist/components/Input/WInput.vue.js

@@ -0,0 +1,397 @@
+import { defineComponent, ref, onMounted, onBeforeUnmount, openBlock, createElementBlock, normalizeClass, Fragment, renderSlot, createTextVNode, toDisplayString, createVNode, Transition, withCtx, createCommentVNode, createBlock, createElementVNode, normalizeStyle, withModifiers, resolveDynamicComponent, withKeys, createSlots, unref, nextTick } from 'vue';
+import WSkeleton from '../Skeleton/WSkeleton.vue.js';
+import _sfc_main$1 from './components/InputActions.vue.js';
+import { Notify } from '../../utils/Notify.js';
+import { numberFormatter, genId } from '../../utils/utils.js';
+import { useTabActiveListener } from '../Tabs/use/useTabActiveListener.js';
+
+const _hoisted_1 = {
+  key: 0,
+  class: "text-negative dark:text-negative-dark"
+};
+const _hoisted_2 = { class: "grid grid-cols-[1fr,auto]" };
+const _hoisted_3 = {
+  key: 0,
+  class: "absolute top-0 left-0 h-full flex items-center justify-center px-3 text-description select-none"
+};
+const _hoisted_4 = {
+  key: 0,
+  class: "text-xs font-normal text-negative dark:text-negative-dark absolute right-0 pt-0.5 text-end"
+};
+const _hoisted_5 = {
+  key: 1,
+  class: "text-xs font-normal text-description absolute right-0 pt-0.5 whitespace-nowrap"
+};
+const _hoisted_6 = {
+  key: 2,
+  ref: "rightContainer",
+  class: "pl-4 flex gap-4 sm-not:flex-col"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WInput",
+  props: {
+    modelValue: { default: void 0 },
+    title: { default: void 0 },
+    description: { default: void 0 },
+    placeholder: { default: void 0 },
+    type: { default: void 0 },
+    name: { default: void 0 },
+    autocomplete: { default: "off" },
+    autofocus: { type: Boolean },
+    textarea: { type: Boolean },
+    disabled: { type: Boolean },
+    allowClear: { type: Boolean },
+    errorMessage: { default: void 0 },
+    readonly: { type: Boolean },
+    icon: { default: void 0 },
+    maxLength: { default: void 0 },
+    loading: { type: Boolean },
+    required: { type: Boolean },
+    hideInput: { type: Boolean },
+    skeleton: { type: Boolean },
+    size: { default: 20 },
+    mono: { type: Boolean },
+    textSecure: { type: Boolean },
+    spellcheck: { type: Boolean },
+    placeholderSecure: { type: Boolean },
+    customBackspaceHandle: { type: Boolean },
+    hasChanges: { type: Boolean },
+    disabledActions: { type: Boolean },
+    noMargin: { type: Boolean },
+    resize: { type: Boolean },
+    allowPaste: { type: Boolean }
+  },
+  emits: ["update:modelValue", "keypress:enter", "keypress:up", "keypress:down", "keypress:delete", "keypress:backspace", "click:clear", "focus", "blur", "click", "mousedown", "click:internal", "select:input", "paste"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const inputId = `w-input-${genId()}`;
+    const input = ref();
+    const isFocused = ref(false);
+    const isSecureVisible = ref(false);
+    const paddingRight = ref(0);
+    const updateModelValue = (value) => {
+      if (props.loading || props.disabled || props.readonly)
+        return;
+      if (props.type === "number") {
+        emit("update:modelValue", typeof value === "string" && value.length ? Number.parseFloat(value) : void 0);
+      } else {
+        emit("update:modelValue", value);
+      }
+    };
+    const handleBackspace = (event) => {
+      if (!props.customBackspaceHandle)
+        return;
+      event.preventDefault();
+      event.stopPropagation();
+      const target = event.target;
+      const value = target?.value;
+      if (!value || target.selectionStart === null || target.selectionEnd === null)
+        return;
+      let substring;
+      let selectionStart;
+      if (target.selectionStart === target.selectionEnd) {
+        if (target.selectionStart === 0)
+          return;
+        selectionStart = target.selectionStart - 1;
+        substring = value.substring(0, selectionStart) + value.substring(target.selectionEnd);
+      } else {
+        selectionStart = target.selectionStart;
+        substring = value.substring(0, selectionStart) + value.substring(target.selectionEnd);
+      }
+      target.value = substring;
+      updateModelValue(substring);
+      nextTick().then(() => target.setSelectionRange(selectionStart, selectionStart));
+    };
+    const handleInputEvent = (event) => {
+      const target = event.target;
+      const value = target?.value;
+      if (props.maxLength && typeof value === "string" && value.length > props.maxLength) {
+        event.preventDefault();
+        const substring = value.substring(0, props.maxLength);
+        if (target)
+          target.value = substring;
+        updateModelValue(substring);
+        return;
+      }
+      updateModelValue(value);
+    };
+    const clearValue = () => {
+      if (props.disabled || props.readonly)
+        return;
+      updateModelValue(void 0);
+      input.value?.focus();
+      emit("click:clear");
+    };
+    const focus = () => {
+      if (props.disabled || props.readonly)
+        return;
+      if (isFocused.value)
+        return;
+      input.value?.focus();
+    };
+    const blur = () => {
+      input.value?.blur();
+    };
+    const setIsFocused = (value) => {
+      isFocused.value = value;
+    };
+    const checkPermission = async () => {
+      const result = await navigator.permissions.query({ name: "clipboard-read" });
+      return result.state === "granted" || result.state === "prompt";
+    };
+    const paste = async () => {
+      if (!await checkPermission()) {
+        Notify.error({
+          title: "Paste failed",
+          caption: "Reading from clipboard is not permitted"
+        });
+        return;
+      }
+      navigator.clipboard.readText().then((value) => {
+        if (!value) {
+          Notify.warn({
+            title: "Nothing to paste"
+          });
+          return;
+        }
+        if (!props.maxLength || props.maxLength <= value.length) {
+          updateModelValue(value);
+          Notify.success({
+            title: "Pasted"
+          });
+          nextTick().then(() => emit("paste"));
+        } else {
+          Notify.error({
+            title: "Unable to paste",
+            caption: "The length of the pasted value exceeds the allowed limit"
+          });
+        }
+      }).catch(() => {
+        Notify.error({
+          title: "Paste failed"
+        });
+      });
+    };
+    let timeout;
+    const autofocusDebounced = () => {
+      if (timeout)
+        clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        if (props.autofocus)
+          focus();
+        timeout = void 0;
+      }, 250);
+    };
+    if (props.autofocus) {
+      useTabActiveListener(autofocusDebounced);
+    }
+    onMounted(() => {
+      if (props.autofocus)
+        autofocusDebounced();
+    });
+    onBeforeUnmount(() => {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+    });
+    __expose({
+      focus,
+      blur
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["relative", {
+          "cursor-not-allowed": _ctx.disabled && !_ctx.skeleton,
+          "mt-1 mb-[1.125rem]": !_ctx.noMargin
+        }]),
+        onClick: _cache[14] || (_cache[14] = ($event) => _ctx.$emit("click:internal", $event))
+      }, [
+        _ctx.title || _ctx.$slots.title?.()?.length ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: normalizeClass(["text-xs font-semibold text-accent mb-2 duration-500", {
+            "opacity-50": _ctx.disabled && !_ctx.skeleton
+          }])
+        }, [
+          !_ctx.skeleton ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            renderSlot(_ctx.$slots, "title", {}, () => [
+              createTextVNode(toDisplayString(_ctx.title), 1)
+            ]),
+            createVNode(Transition, {
+              "enter-active-class": "transition-opacity",
+              "leave-active-class": "transition-opacity",
+              "enter-from-class": "opacity-0",
+              "leave-to-class": "opacity-0"
+            }, {
+              default: withCtx(() => [
+                _ctx.required ? (openBlock(), createElementBlock("span", _hoisted_1, " * ")) : createCommentVNode("", true)
+              ]),
+              _: 1
+            })
+          ], 64)) : (openBlock(), createBlock(WSkeleton, {
+            key: 1,
+            class: "h-4 w-16"
+          }))
+        ], 2)) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_2, [
+          !_ctx.skeleton ? (openBlock(), createElementBlock("label", {
+            key: 0,
+            class: "relative isolate",
+            for: inputId
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(["relative flex flex-wrap border border-solid rounded-xl bg-default dark:bg-default-dark transition-colors duration-75 overflow-hidden min-h-11 w-full", {
+                "focus-within:border-primary-default dark:focus-within:border-primary-dark": !_ctx.disabled && !_ctx.readonly,
+                "cursor-text": !_ctx.disabled,
+                "pl-1 py-1 gap-1": _ctx.$slots.suffix?.()?.length,
+                "pl-11": _ctx.icon,
+                "border-negative dark:border-negative-dark": _ctx.errorMessage,
+                "border-gray-300 dark:border-gray-700": !_ctx.disabled,
+                "border-gray-300/50 dark:border-gray-700/50": _ctx.disabled
+              }]),
+              style: normalizeStyle({ paddingRight: paddingRight.value + "px" }),
+              onClick: focus,
+              onMousedown: _cache[13] || (_cache[13] = withModifiers(() => {
+              }, ["prevent"]))
+            }, [
+              _ctx.icon ? (openBlock(), createElementBlock("div", _hoisted_3, [
+                (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon), { class: "w-5 h-5" }))
+              ])) : createCommentVNode("", true),
+              renderSlot(_ctx.$slots, "prefix"),
+              (openBlock(), createBlock(resolveDynamicComponent(_ctx.textarea ? "textarea" : "input"), {
+                id: inputId,
+                ref_key: "input",
+                ref: input,
+                class: normalizeClass(["text-base font-normal outline-0 border-none bg-[inherit] flex-1 max-w-full disabled:opacity-80 disabled:cursor-not-allowed placeholder:text-gray-400 dark:placeholder:text-gray-500 appearance-none", {
+                  "min-h-[var(--textarea-height,160px)] w-full p-3": _ctx.textarea,
+                  "resize-y": _ctx.resize && _ctx.textarea,
+                  "resize-none": !_ctx.resize && _ctx.textarea,
+                  "h-[var(--input-height,42px)]": !_ctx.textarea && !_ctx.$slots.suffix?.()?.length,
+                  "h-[var(--input-height,34px)]": !_ctx.textarea && _ctx.$slots.suffix?.()?.length,
+                  "py-0 pr-1": !_ctx.hideInput && !_ctx.textarea,
+                  "pl-3": !_ctx.hideInput && !_ctx.textarea && !_ctx.icon,
+                  "w-0 max-w-0 p-0 absolute": _ctx.hideInput,
+                  "font-mono": _ctx.mono,
+                  "text-secure": _ctx.textSecure && !isSecureVisible.value,
+                  "text-black-default dark:text-gray-200": !_ctx.disabled,
+                  "text-black-default/50 dark:text-gray-200/50": _ctx.disabled
+                }]),
+                value: _ctx.placeholderSecure && _ctx.modelValue === void 0 && !isFocused.value ? "******" : _ctx.modelValue,
+                placeholder: _ctx.placeholder,
+                type: _ctx.type ?? "text",
+                name: _ctx.name,
+                disabled: _ctx.disabled,
+                readonly: _ctx.readonly,
+                autocomplete: _ctx.autocomplete,
+                size: _ctx.size || void 0,
+                spellcheck: _ctx.spellcheck ? "true" : "false",
+                onInput: handleInputEvent,
+                onKeypress: _cache[0] || (_cache[0] = withKeys(withModifiers(($event) => !_ctx.disabled && !_ctx.readonly && _ctx.$emit("keypress:enter", $event), ["exact"]), ["enter"])),
+                onKeydown: [
+                  _cache[1] || (_cache[1] = withKeys(withModifiers(($event) => !_ctx.disabled && !_ctx.readonly && _ctx.$emit("keypress:up", $event), ["exact", "stop"]), ["up"])),
+                  _cache[2] || (_cache[2] = withKeys(withModifiers(($event) => !_ctx.disabled && !_ctx.readonly && _ctx.$emit("keypress:down", $event), ["exact", "stop"]), ["down"])),
+                  _cache[3] || (_cache[3] = withKeys(withModifiers(($event) => {
+                    !_ctx.disabled && !_ctx.readonly && _ctx.$emit("keypress:delete", $event);
+                    handleBackspace($event);
+                  }, ["exact", "stop"]), ["delete"]))
+                ],
+                onFocus: _cache[4] || (_cache[4] = ($event) => {
+                  _ctx.$emit("focus", $event);
+                  setIsFocused(true);
+                }),
+                onBlur: _cache[5] || (_cache[5] = ($event) => {
+                  _ctx.$emit("blur", $event);
+                  setIsFocused(false);
+                  isSecureVisible.value = false;
+                }),
+                onClick: _cache[6] || (_cache[6] = ($event) => _ctx.$emit("click", $event)),
+                onMousedown: _cache[7] || (_cache[7] = withModifiers(($event) => _ctx.$emit("mousedown", $event), ["stop"])),
+                onSelect: _cache[8] || (_cache[8] = ($event) => _ctx.$emit("select:input", $event))
+              }, null, 40, ["class", "value", "placeholder", "type", "name", "disabled", "readonly", "autocomplete", "size", "spellcheck"])),
+              createVNode(_sfc_main$1, {
+                loading: _ctx.loading,
+                "allow-clear": _ctx.allowClear && _ctx.modelValue !== "",
+                disabled: _ctx.disabled || _ctx.readonly || _ctx.disabledActions,
+                "text-secure": _ctx.textSecure,
+                "is-secure-visible": isSecureVisible.value,
+                "allow-paste": _ctx.allowPaste,
+                class: "absolute top-0 right-0 bottom-0",
+                "onClick:clear": clearValue,
+                "onClick:slot": _cache[9] || (_cache[9] = ($event) => {
+                  isFocused.value ? blur() : focus();
+                  _ctx.$emit("click:internal", $event);
+                }),
+                "onShow:secure": _cache[10] || (_cache[10] = ($event) => {
+                  isSecureVisible.value = true;
+                  _ctx.$emit("click", $event);
+                }),
+                "onHide:secure": _cache[11] || (_cache[11] = ($event) => isSecureVisible.value = false),
+                "onUpdate:width": _cache[12] || (_cache[12] = ($event) => paddingRight.value = $event),
+                "onClick:paste": paste
+              }, createSlots({ _: 2 }, [
+                _ctx.$slots.suffix?.()?.length ? {
+                  name: "default",
+                  fn: withCtx(() => [
+                    renderSlot(_ctx.$slots, "suffix")
+                  ]),
+                  key: "0"
+                } : void 0
+              ]), 1032, ["loading", "allow-clear", "disabled", "text-secure", "is-secure-visible", "allow-paste"])
+            ], 38),
+            createVNode(Transition, {
+              "enter-active-class": "transition-opacity",
+              "leave-active-class": "transition-opacity",
+              "enter-from-class": "opacity-0",
+              "leave-to-class": "opacity-0"
+            }, {
+              default: withCtx(() => [
+                _ctx.hasChanges ? (openBlock(), createElementBlock("span", {
+                  key: 0,
+                  class: normalizeClass(["square-2 rounded-full transition-colors absolute top-0 right-0 z-10", {
+                    "bg-info dark:bg-info-dark": isFocused.value || _ctx.errorMessage === void 0,
+                    "bg-negative dark:bg-negative-dark": !isFocused.value && _ctx.errorMessage !== void 0
+                  }])
+                }, null, 2)) : createCommentVNode("", true)
+              ]),
+              _: 1
+            }),
+            createVNode(Transition, {
+              "enter-active-class": "transition-opacity",
+              "leave-active-class": "transition-opacity",
+              "enter-from-class": "opacity-0",
+              "leave-to-class": "opacity-0"
+            }, {
+              default: withCtx(() => [
+                _ctx.errorMessage ? (openBlock(), createElementBlock("div", _hoisted_4, toDisplayString(_ctx.errorMessage), 1)) : _ctx.maxLength !== void 0 && isFocused.value ? (openBlock(), createElementBlock("div", _hoisted_5, toDisplayString(unref(numberFormatter).format(String(_ctx.modelValue || "").length)) + " / " + toDisplayString(unref(numberFormatter).format(_ctx.maxLength)), 1)) : createCommentVNode("", true)
+              ]),
+              _: 1
+            })
+          ])) : (openBlock(), createBlock(WSkeleton, {
+            key: 1,
+            class: normalizeClass(["w-full w-skeleton-rounded-xl", {
+              "h-[calc(var(--textarea-height,160px)+2px)]": _ctx.textarea,
+              "h-[calc(var(--input-height,42px)+2px)]": !_ctx.textarea && !_ctx.$slots.suffix?.()?.length,
+              "h-[calc(var(--input-height,34px)+10px)]": !_ctx.textarea && _ctx.$slots.suffix?.()?.length
+            }]),
+            style: { "--skeleton-width": "100%" }
+          }, null, 8, ["class"])),
+          _ctx.$slots.right?.()?.length ? (openBlock(), createElementBlock("div", _hoisted_6, [
+            renderSlot(_ctx.$slots, "right")
+          ], 512)) : createCommentVNode("", true)
+        ]),
+        _ctx.description ? (openBlock(), createElementBlock("div", {
+          key: 1,
+          class: normalizeClass(["text-xs font-normal text-description pt-4 whitespace-pre-wrap break-words text-pretty", {
+            "opacity-50": _ctx.disabled && !_ctx.skeleton
+          }])
+        }, [
+          _ctx.skeleton ? (openBlock(), createBlock(WSkeleton, { key: 0 })) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+            createTextVNode(toDisplayString(_ctx.description), 1)
+          ], 64))
+        ], 2)) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Input/WInput.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './WInput.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/Input/WInputAsync.vue.d.ts

@@ -0,0 +1,126 @@
+declare const _default: <Type extends InputType = "text">(__VLS_props: {
+    modelValue?: (Type extends "number" ? number : string) | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    validate?: ValidateFn | ValidateFn[] | undefined;
+    type?: Type | undefined;
+    placeholder?: string | undefined;
+    loading?: boolean | undefined;
+    disabled?: boolean | undefined;
+    skeleton?: boolean | undefined;
+    textarea?: boolean | undefined;
+    name?: string | undefined;
+    mono?: boolean | undefined;
+    textSecure?: boolean | undefined;
+    placeholderSecure?: boolean | undefined;
+    maxLength?: number | undefined;
+    required?: boolean | undefined;
+    hasChanges?: boolean | undefined;
+    errorMessage?: string | undefined;
+    noMargin?: boolean | undefined;
+    resize?: boolean | undefined;
+    allowPaste?: boolean | undefined;
+    icon?: SVGComponent | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: Pick<{
+    props: {
+        modelValue?: (Type extends "number" ? number : string) | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        validate?: ValidateFn | ValidateFn[] | undefined;
+        type?: Type | undefined;
+        placeholder?: string | undefined;
+        loading?: boolean | undefined;
+        disabled?: boolean | undefined;
+        skeleton?: boolean | undefined;
+        textarea?: boolean | undefined;
+        name?: string | undefined;
+        mono?: boolean | undefined;
+        textSecure?: boolean | undefined;
+        placeholderSecure?: boolean | undefined;
+        maxLength?: number | undefined;
+        required?: boolean | undefined;
+        hasChanges?: boolean | undefined;
+        errorMessage?: string | undefined;
+        noMargin?: boolean | undefined;
+        resize?: boolean | undefined;
+        allowPaste?: boolean | undefined;
+        icon?: SVGComponent | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: {
+        title?(_: {}): any;
+        right?(_: {}): any;
+    };
+    emit: (e: 'update:modelValue', value: (Type extends "number" ? number : string) | undefined) => void;
+}, "attrs" | "slots" | "emit"> | undefined, __VLS_setup?: {
+    props: {
+        modelValue?: (Type extends "number" ? number : string) | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        validate?: ValidateFn | ValidateFn[] | undefined;
+        type?: Type | undefined;
+        placeholder?: string | undefined;
+        loading?: boolean | undefined;
+        disabled?: boolean | undefined;
+        skeleton?: boolean | undefined;
+        textarea?: boolean | undefined;
+        name?: string | undefined;
+        mono?: boolean | undefined;
+        textSecure?: boolean | undefined;
+        placeholderSecure?: boolean | undefined;
+        maxLength?: number | undefined;
+        required?: boolean | undefined;
+        hasChanges?: boolean | undefined;
+        errorMessage?: string | undefined;
+        noMargin?: boolean | undefined;
+        resize?: boolean | undefined;
+        allowPaste?: boolean | undefined;
+        icon?: SVGComponent | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: {
+        title?(_: {}): any;
+        right?(_: {}): any;
+    };
+    emit: (e: 'update:modelValue', value: (Type extends "number" ? number : string) | undefined) => void;
+}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            modelValue?: (Type extends "number" ? number : string) | undefined;
+            title?: string | undefined;
+            description?: string | undefined;
+            validate?: ValidateFn | ValidateFn[] | undefined;
+            type?: Type | undefined;
+            placeholder?: string | undefined;
+            loading?: boolean | undefined;
+            disabled?: boolean | undefined;
+            skeleton?: boolean | undefined;
+            textarea?: boolean | undefined;
+            name?: string | undefined;
+            mono?: boolean | undefined;
+            textSecure?: boolean | undefined;
+            placeholderSecure?: boolean | undefined;
+            maxLength?: number | undefined;
+            required?: boolean | undefined;
+            hasChanges?: boolean | undefined;
+            errorMessage?: string | undefined;
+            noMargin?: boolean | undefined;
+            resize?: boolean | undefined;
+            allowPaste?: boolean | undefined;
+            icon?: SVGComponent | undefined;
+        };
+        expose(exposed: {}): void;
+        attrs: any;
+        slots: {
+            title?(_: {}): any;
+            right?(_: {}): any;
+        };
+        emit: (e: 'update:modelValue', value: (Type extends "number" ? number : string) | undefined) => void;
+    } | undefined;
+};
+export default _default;
+//# sourceMappingURL=WInputAsync.vue.d.ts.map

package/dist/components/Input/WInputAsync.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WInputAsync.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Input/WInputAsync.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA4YuC,IAAI;WACpC,GAAG;;uBAzDkB,GAAG;uBACH,GAAG;;cAmDzB,mBAAmB,mEAAkC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;yBAIxB,IAAI;WACpC,GAAG;;uBAzDkB,GAAG;uBACH,GAAG;;cAmDzB,mBAAmB,mEAAkC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAIxB,IAAI;eACpC,GAAG;;2BAzDkB,GAAG;2BACH,GAAG;;kBAmDzB,mBAAmB,mEAAkC,IAAI;;;AA7X/D,wBAsYkE"}