News Post 6 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed cursus, odio nec venenatis lacinia, lacus lectus varius nisi, in tristique mi purus ut libero.
TailBliss
-
TailBliss
TailBliss
+
TailBliss
2022-03-18
·
2
min read
News Post 3 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed cursus, odio nec venenatis lacinia, lacus lectus varius nisi, in tristique mi purus ut libero.
TailBliss
-
TailBliss
TailBliss
+
TailBliss
2021-12-18
·
2
min read
diff --git a/public/js/alpine.js b/public/js/alpine.js
index 164bdab..b689e5f 100644
--- a/public/js/alpine.js
+++ b/public/js/alpine.js
@@ -1,5 +1,713 @@
(() => {
- // node_modules/.pnpm/alpinejs@3.12.0/node_modules/alpinejs/dist/module.esm.js
+ // node_modules/.pnpm/@vue+shared@3.1.5/node_modules/@vue/shared/dist/shared.esm-bundler.js
+ function makeMap(str, expectsLowerCase) {
+ const map = /* @__PURE__ */ Object.create(null);
+ const list = str.split(",");
+ for (let i = 0; i < list.length; i++) {
+ map[list[i]] = true;
+ }
+ return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+ }
+ var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+ var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
+ var EMPTY_OBJ = true ? Object.freeze({}) : {};
+ var EMPTY_ARR = true ? Object.freeze([]) : [];
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+ var isArray = Array.isArray;
+ var isMap = (val) => toTypeString(val) === "[object Map]";
+ var isString = (val) => typeof val === "string";
+ var isSymbol = (val) => typeof val === "symbol";
+ var isObject = (val) => val !== null && typeof val === "object";
+ var objectToString = Object.prototype.toString;
+ var toTypeString = (value) => objectToString.call(value);
+ var toRawType = (value) => {
+ return toTypeString(value).slice(8, -1);
+ };
+ var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+ var cacheStringFunction = (fn) => {
+ const cache = /* @__PURE__ */ Object.create(null);
+ return (str) => {
+ const hit = cache[str];
+ return hit || (cache[str] = fn(str));
+ };
+ };
+ var camelizeRE = /-(\w)/g;
+ var camelize = cacheStringFunction((str) => {
+ return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+ });
+ var hyphenateRE = /\B([A-Z])/g;
+ var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+ var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
+ var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
+ var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
+
+ // node_modules/.pnpm/@vue+reactivity@3.1.5/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+ var targetMap = /* @__PURE__ */ new WeakMap();
+ var effectStack = [];
+ var activeEffect;
+ var ITERATE_KEY = Symbol(true ? "iterate" : "");
+ var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : "");
+ function isEffect(fn) {
+ return fn && fn._isEffect === true;
+ }
+ function effect(fn, options = EMPTY_OBJ) {
+ if (isEffect(fn)) {
+ fn = fn.raw;
+ }
+ const effect3 = createReactiveEffect(fn, options);
+ if (!options.lazy) {
+ effect3();
+ }
+ return effect3;
+ }
+ function stop(effect3) {
+ if (effect3.active) {
+ cleanup(effect3);
+ if (effect3.options.onStop) {
+ effect3.options.onStop();
+ }
+ effect3.active = false;
+ }
+ }
+ var uid = 0;
+ function createReactiveEffect(fn, options) {
+ const effect3 = function reactiveEffect() {
+ if (!effect3.active) {
+ return fn();
+ }
+ if (!effectStack.includes(effect3)) {
+ cleanup(effect3);
+ try {
+ enableTracking();
+ effectStack.push(effect3);
+ activeEffect = effect3;
+ return fn();
+ } finally {
+ effectStack.pop();
+ resetTracking();
+ activeEffect = effectStack[effectStack.length - 1];
+ }
+ }
+ };
+ effect3.id = uid++;
+ effect3.allowRecurse = !!options.allowRecurse;
+ effect3._isEffect = true;
+ effect3.active = true;
+ effect3.raw = fn;
+ effect3.deps = [];
+ effect3.options = options;
+ return effect3;
+ }
+ function cleanup(effect3) {
+ const { deps } = effect3;
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].delete(effect3);
+ }
+ deps.length = 0;
+ }
+ }
+ var shouldTrack = true;
+ var trackStack = [];
+ function pauseTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = false;
+ }
+ function enableTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = true;
+ }
+ function resetTracking() {
+ const last = trackStack.pop();
+ shouldTrack = last === void 0 ? true : last;
+ }
+ function track(target, type, key) {
+ if (!shouldTrack || activeEffect === void 0) {
+ return;
+ }
+ let depsMap = targetMap.get(target);
+ if (!depsMap) {
+ targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+ }
+ let dep = depsMap.get(key);
+ if (!dep) {
+ depsMap.set(key, dep = /* @__PURE__ */ new Set());
+ }
+ if (!dep.has(activeEffect)) {
+ dep.add(activeEffect);
+ activeEffect.deps.push(dep);
+ if (activeEffect.options.onTrack) {
+ activeEffect.options.onTrack({
+ effect: activeEffect,
+ target,
+ type,
+ key
+ });
+ }
+ }
+ }
+ function trigger(target, type, key, newValue, oldValue, oldTarget) {
+ const depsMap = targetMap.get(target);
+ if (!depsMap) {
+ return;
+ }
+ const effects = /* @__PURE__ */ new Set();
+ const add2 = (effectsToAdd) => {
+ if (effectsToAdd) {
+ effectsToAdd.forEach((effect3) => {
+ if (effect3 !== activeEffect || effect3.allowRecurse) {
+ effects.add(effect3);
+ }
+ });
+ }
+ };
+ if (type === "clear") {
+ depsMap.forEach(add2);
+ } else if (key === "length" && isArray(target)) {
+ depsMap.forEach((dep, key2) => {
+ if (key2 === "length" || key2 >= newValue) {
+ add2(dep);
+ }
+ });
+ } else {
+ if (key !== void 0) {
+ add2(depsMap.get(key));
+ }
+ switch (type) {
+ case "add":
+ if (!isArray(target)) {
+ add2(depsMap.get(ITERATE_KEY));
+ if (isMap(target)) {
+ add2(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ } else if (isIntegerKey(key)) {
+ add2(depsMap.get("length"));
+ }
+ break;
+ case "delete":
+ if (!isArray(target)) {
+ add2(depsMap.get(ITERATE_KEY));
+ if (isMap(target)) {
+ add2(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ }
+ break;
+ case "set":
+ if (isMap(target)) {
+ add2(depsMap.get(ITERATE_KEY));
+ }
+ break;
+ }
+ }
+ const run = (effect3) => {
+ if (effect3.options.onTrigger) {
+ effect3.options.onTrigger({
+ effect: effect3,
+ target,
+ key,
+ type,
+ newValue,
+ oldValue,
+ oldTarget
+ });
+ }
+ if (effect3.options.scheduler) {
+ effect3.options.scheduler(effect3);
+ } else {
+ effect3();
+ }
+ };
+ effects.forEach(run);
+ }
+ var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+ var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
+ var get = /* @__PURE__ */ createGetter();
+ var readonlyGet = /* @__PURE__ */ createGetter(true);
+ var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+ function createArrayInstrumentations() {
+ const instrumentations = {};
+ ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+ instrumentations[key] = function(...args) {
+ const arr = toRaw(this);
+ for (let i = 0, l = this.length; i < l; i++) {
+ track(arr, "get", i + "");
+ }
+ const res = arr[key](...args);
+ if (res === -1 || res === false) {
+ return arr[key](...args.map(toRaw));
+ } else {
+ return res;
+ }
+ };
+ });
+ ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+ instrumentations[key] = function(...args) {
+ pauseTracking();
+ const res = toRaw(this)[key].apply(this, args);
+ resetTracking();
+ return res;
+ };
+ });
+ return instrumentations;
+ }
+ function createGetter(isReadonly = false, shallow = false) {
+ return function get3(target, key, receiver) {
+ if (key === "__v_isReactive") {
+ return !isReadonly;
+ } else if (key === "__v_isReadonly") {
+ return isReadonly;
+ } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
+ return target;
+ }
+ const targetIsArray = isArray(target);
+ if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
+ return Reflect.get(arrayInstrumentations, key, receiver);
+ }
+ const res = Reflect.get(target, key, receiver);
+ if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+ return res;
+ }
+ if (!isReadonly) {
+ track(target, "get", key);
+ }
+ if (shallow) {
+ return res;
+ }
+ if (isRef(res)) {
+ const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
+ return shouldUnwrap ? res.value : res;
+ }
+ if (isObject(res)) {
+ return isReadonly ? readonly(res) : reactive(res);
+ }
+ return res;
+ };
+ }
+ var set = /* @__PURE__ */ createSetter();
+ function createSetter(shallow = false) {
+ return function set3(target, key, value, receiver) {
+ let oldValue = target[key];
+ if (!shallow) {
+ value = toRaw(value);
+ oldValue = toRaw(oldValue);
+ if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ }
+ }
+ const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+ const result = Reflect.set(target, key, value, receiver);
+ if (target === toRaw(receiver)) {
+ if (!hadKey) {
+ trigger(target, "add", key, value);
+ } else if (hasChanged(value, oldValue)) {
+ trigger(target, "set", key, value, oldValue);
+ }
+ }
+ return result;
+ };
+ }
+ function deleteProperty(target, key) {
+ const hadKey = hasOwn(target, key);
+ const oldValue = target[key];
+ const result = Reflect.deleteProperty(target, key);
+ if (result && hadKey) {
+ trigger(target, "delete", key, void 0, oldValue);
+ }
+ return result;
+ }
+ function has(target, key) {
+ const result = Reflect.has(target, key);
+ if (!isSymbol(key) || !builtInSymbols.has(key)) {
+ track(target, "has", key);
+ }
+ return result;
+ }
+ function ownKeys(target) {
+ track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+ return Reflect.ownKeys(target);
+ }
+ var mutableHandlers = {
+ get,
+ set,
+ deleteProperty,
+ has,
+ ownKeys
+ };
+ var readonlyHandlers = {
+ get: readonlyGet,
+ set(target, key) {
+ if (true) {
+ console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+ }
+ return true;
+ },
+ deleteProperty(target, key) {
+ if (true) {
+ console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+ }
+ return true;
+ }
+ };
+ var toReactive = (value) => isObject(value) ? reactive(value) : value;
+ var toReadonly = (value) => isObject(value) ? readonly(value) : value;
+ var toShallow = (value) => value;
+ var getProto = (v) => Reflect.getPrototypeOf(v);
+ function get$1(target, key, isReadonly = false, isShallow = false) {
+ target = target[
+ "__v_raw"
+ /* RAW */
+ ];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (key !== rawKey) {
+ !isReadonly && track(rawTarget, "get", key);
+ }
+ !isReadonly && track(rawTarget, "get", rawKey);
+ const { has: has2 } = getProto(rawTarget);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ if (has2.call(rawTarget, key)) {
+ return wrap(target.get(key));
+ } else if (has2.call(rawTarget, rawKey)) {
+ return wrap(target.get(rawKey));
+ } else if (target !== rawTarget) {
+ target.get(key);
+ }
+ }
+ function has$1(key, isReadonly = false) {
+ const target = this[
+ "__v_raw"
+ /* RAW */
+ ];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (key !== rawKey) {
+ !isReadonly && track(rawTarget, "has", key);
+ }
+ !isReadonly && track(rawTarget, "has", rawKey);
+ return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+ }
+ function size(target, isReadonly = false) {
+ target = target[
+ "__v_raw"
+ /* RAW */
+ ];
+ !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
+ return Reflect.get(target, "size", target);
+ }
+ function add(value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const proto = getProto(target);
+ const hadKey = proto.has.call(target, value);
+ if (!hadKey) {
+ target.add(value);
+ trigger(target, "add", value, value);
+ }
+ return this;
+ }
+ function set$1(key, value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const { has: has2, get: get3 } = getProto(target);
+ let hadKey = has2.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has2.call(target, key);
+ } else if (true) {
+ checkIdentityKeys(target, has2, key);
+ }
+ const oldValue = get3.call(target, key);
+ target.set(key, value);
+ if (!hadKey) {
+ trigger(target, "add", key, value);
+ } else if (hasChanged(value, oldValue)) {
+ trigger(target, "set", key, value, oldValue);
+ }
+ return this;
+ }
+ function deleteEntry(key) {
+ const target = toRaw(this);
+ const { has: has2, get: get3 } = getProto(target);
+ let hadKey = has2.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has2.call(target, key);
+ } else if (true) {
+ checkIdentityKeys(target, has2, key);
+ }
+ const oldValue = get3 ? get3.call(target, key) : void 0;
+ const result = target.delete(key);
+ if (hadKey) {
+ trigger(target, "delete", key, void 0, oldValue);
+ }
+ return result;
+ }
+ function clear() {
+ const target = toRaw(this);
+ const hadItems = target.size !== 0;
+ const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
+ const result = target.clear();
+ if (hadItems) {
+ trigger(target, "clear", void 0, void 0, oldTarget);
+ }
+ return result;
+ }
+ function createForEach(isReadonly, isShallow) {
+ return function forEach(callback, thisArg) {
+ const observed = this;
+ const target = observed[
+ "__v_raw"
+ /* RAW */
+ ];
+ const rawTarget = toRaw(target);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
+ return target.forEach((value, key) => {
+ return callback.call(thisArg, wrap(value), wrap(key), observed);
+ });
+ };
+ }
+ function createIterableMethod(method, isReadonly, isShallow) {
+ return function(...args) {
+ const target = this[
+ "__v_raw"
+ /* RAW */
+ ];
+ const rawTarget = toRaw(target);
+ const targetIsMap = isMap(rawTarget);
+ const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+ const isKeyOnly = method === "keys" && targetIsMap;
+ const innerIterator = target[method](...args);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+ return {
+ // iterator protocol
+ next() {
+ const { value, done } = innerIterator.next();
+ return done ? { value, done } : {
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+ done
+ };
+ },
+ // iterable protocol
+ [Symbol.iterator]() {
+ return this;
+ }
+ };
+ };
+ }
+ function createReadonlyMethod(type) {
+ return function(...args) {
+ if (true) {
+ const key = args[0] ? `on key "${args[0]}" ` : ``;
+ console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+ }
+ return type === "delete" ? false : this;
+ };
+ }
+ function createInstrumentations() {
+ const mutableInstrumentations2 = {
+ get(key) {
+ return get$1(this, key);
+ },
+ get size() {
+ return size(this);
+ },
+ has: has$1,
+ add,
+ set: set$1,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, false)
+ };
+ const shallowInstrumentations2 = {
+ get(key) {
+ return get$1(this, key, false, true);
+ },
+ get size() {
+ return size(this);
+ },
+ has: has$1,
+ add,
+ set: set$1,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, true)
+ };
+ const readonlyInstrumentations2 = {
+ get(key) {
+ return get$1(this, key, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has$1.call(this, key, true);
+ },
+ add: createReadonlyMethod(
+ "add"
+ /* ADD */
+ ),
+ set: createReadonlyMethod(
+ "set"
+ /* SET */
+ ),
+ delete: createReadonlyMethod(
+ "delete"
+ /* DELETE */
+ ),
+ clear: createReadonlyMethod(
+ "clear"
+ /* CLEAR */
+ ),
+ forEach: createForEach(true, false)
+ };
+ const shallowReadonlyInstrumentations2 = {
+ get(key) {
+ return get$1(this, key, true, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has$1.call(this, key, true);
+ },
+ add: createReadonlyMethod(
+ "add"
+ /* ADD */
+ ),
+ set: createReadonlyMethod(
+ "set"
+ /* SET */
+ ),
+ delete: createReadonlyMethod(
+ "delete"
+ /* DELETE */
+ ),
+ clear: createReadonlyMethod(
+ "clear"
+ /* CLEAR */
+ ),
+ forEach: createForEach(true, true)
+ };
+ const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+ iteratorMethods.forEach((method) => {
+ mutableInstrumentations2[method] = createIterableMethod(method, false, false);
+ readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
+ shallowInstrumentations2[method] = createIterableMethod(method, false, true);
+ shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
+ });
+ return [
+ mutableInstrumentations2,
+ readonlyInstrumentations2,
+ shallowInstrumentations2,
+ shallowReadonlyInstrumentations2
+ ];
+ }
+ var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
+ function createInstrumentationGetter(isReadonly, shallow) {
+ const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
+ return (target, key, receiver) => {
+ if (key === "__v_isReactive") {
+ return !isReadonly;
+ } else if (key === "__v_isReadonly") {
+ return isReadonly;
+ } else if (key === "__v_raw") {
+ return target;
+ }
+ return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+ };
+ }
+ var mutableCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+ };
+ var readonlyCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+ };
+ function checkIdentityKeys(target, has2, key) {
+ const rawKey = toRaw(key);
+ if (rawKey !== key && has2.call(target, rawKey)) {
+ const type = toRawType(target);
+ console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+ }
+ }
+ var reactiveMap = /* @__PURE__ */ new WeakMap();
+ var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+ var readonlyMap = /* @__PURE__ */ new WeakMap();
+ var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+ function targetTypeMap(rawType) {
+ switch (rawType) {
+ case "Object":
+ case "Array":
+ return 1;
+ case "Map":
+ case "Set":
+ case "WeakMap":
+ case "WeakSet":
+ return 2;
+ default:
+ return 0;
+ }
+ }
+ function getTargetType(value) {
+ return value[
+ "__v_skip"
+ /* SKIP */
+ ] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+ }
+ function reactive(target) {
+ if (target && target[
+ "__v_isReadonly"
+ /* IS_READONLY */
+ ]) {
+ return target;
+ }
+ return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+ }
+ function readonly(target) {
+ return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+ }
+ function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
+ if (!isObject(target)) {
+ if (true) {
+ console.warn(`value cannot be made reactive: ${String(target)}`);
+ }
+ return target;
+ }
+ if (target[
+ "__v_raw"
+ /* RAW */
+ ] && !(isReadonly && target[
+ "__v_isReactive"
+ /* IS_REACTIVE */
+ ])) {
+ return target;
+ }
+ const existingProxy = proxyMap.get(target);
+ if (existingProxy) {
+ return existingProxy;
+ }
+ const targetType = getTargetType(target);
+ if (targetType === 0) {
+ return target;
+ }
+ const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+ proxyMap.set(target, proxy);
+ return proxy;
+ }
+ function toRaw(observed) {
+ return observed && toRaw(observed[
+ "__v_raw"
+ /* RAW */
+ ]) || observed;
+ }
+ function isRef(r) {
+ return Boolean(r && r.__v_isRef === true);
+ }
+
+ // node_modules/.pnpm/alpinejs@3.12.1/node_modules/alpinejs/dist/module.esm.js
var flushPending = false;
var flushing = false;
var queue = [];
@@ -34,8 +742,8 @@
lastFlushedIndex = -1;
flushing = false;
}
- var reactive;
- var effect;
+ var reactive2;
+ var effect2;
var release;
var raw;
var shouldSchedule = true;
@@ -45,9 +753,9 @@
shouldSchedule = true;
}
function setReactivityEngine(engine) {
- reactive = engine.reactive;
+ reactive2 = engine.reactive;
release = engine.release;
- effect = (callback) => engine.effect(callback, { scheduler: (task) => {
+ effect2 = (callback) => engine.effect(callback, { scheduler: (task) => {
if (shouldSchedule) {
scheduler(task);
} else {
@@ -57,13 +765,13 @@
raw = engine.raw;
}
function overrideEffect(override) {
- effect = override;
+ effect2 = override;
}
function elementBoundEffect(el) {
let cleanup2 = () => {
};
let wrappedEffect = (callback) => {
- let effectReference = effect(callback);
+ let effectReference = effect2(callback);
if (!el._x_effects) {
el._x_effects = /* @__PURE__ */ new Set();
el._x_runEffects = () => {
@@ -252,12 +960,6 @@
node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
};
}
- function refreshScope(element, scope2) {
- let existingScope = element._x_dataStack[0];
- Object.entries(scope2).forEach(([key, value]) => {
- existingScope[key] = value;
- });
- }
function closestDataStack(node) {
if (node._x_dataStack)
return node._x_dataStack;
@@ -341,7 +1043,7 @@
initialValue: void 0,
_x_interceptor: true,
initialize(data2, path, key) {
- return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
+ return callback(this.initialValue, () => get2(data2, path), (value) => set2(data2, path, value), path, key);
}
};
mutateObj(obj);
@@ -359,10 +1061,10 @@
return obj;
};
}
- function get(obj, path) {
+ function get2(obj, path) {
return path.split(".").reduce((carry, segment) => carry[segment], obj);
}
- function set(obj, path, value) {
+ function set2(obj, path, value) {
if (typeof path === "string")
path = path.split(".");
if (path.length === 1)
@@ -371,10 +1073,10 @@
throw error;
else {
if (obj[path[0]])
- return set(obj[path[0]], path.slice(1), value);
+ return set2(obj[path[0]], path.slice(1), value);
else {
obj[path[0]] = {};
- return set(obj[path[0]], path.slice(1), value);
+ return set2(obj[path[0]], path.slice(1), value);
}
}
}
@@ -384,12 +1086,20 @@
}
function injectMagics(obj, el) {
Object.entries(magics).forEach(([name, callback]) => {
+ let memoizedUtilities = null;
+ function getUtilities() {
+ if (memoizedUtilities) {
+ return memoizedUtilities;
+ } else {
+ let [utilities, cleanup2] = getElementBoundUtilities(el);
+ memoizedUtilities = { interceptor, ...utilities };
+ onElRemoved(el, cleanup2);
+ return memoizedUtilities;
+ }
+ }
Object.defineProperty(obj, `$${name}`, {
get() {
- let [utilities, cleanup2] = getElementBoundUtilities(el);
- utilities = { interceptor, ...utilities };
- onElRemoved(el, cleanup2);
- return callback(el, utilities);
+ return callback(el, getUtilities());
},
enumerable: false
});
@@ -689,7 +1399,11 @@ ${expression ? 'Expression: "' + expression + '"\n\n' : ""}`, el);
function warn(message, ...args) {
console.warn(`Alpine Warning: ${message}`, ...args);
}
+ var started = false;
function start() {
+ if (started)
+ warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
+ started = true;
if (!document.body)
warn("Unable to initialize. Trying to load Alpine before `` is available. Did you forget to add `defer` in Alpine's `
diff --git a/public/tags/index.html b/public/tags/index.html
index 43f305e..4b182a4 100644
--- a/public/tags/index.html
+++ b/public/tags/index.html
@@ -4,10 +4,12 @@
News
Blog 
