Clinio Logo
Clinio
ΔΡΑΣΤΙΚΗ ΟΥΣΙΑ N02AA59

CODEINE, COMBINATIONS EXCL. PSYCHOLEPTICS

Θεραπευτικός παράγοντας σε κλινική χρήση. Δείτε το κλινικό και φαρμακολογικό προφίλ για περισσότερες λεπτομέρειες.

Σκευάσματα & Τιμολόγηση

Δεδομένα ΕΟΦ
Φόρτωση...
e.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); 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 effect2(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 get2 = /* @__PURE__ */ createGetter(); var shallowGet = /* @__PURE__ */ createGetter(false, true); var readonlyGet = /* @__PURE__ */ createGetter(true); var shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true); var arrayInstrumentations = {}; ["includes", "indexOf", "lastIndexOf"].forEach((key) => { const method = Array.prototype[key]; arrayInstrumentations[key] = function(...args) { const arr = toRaw(this); for (let i = 0, l = this.length; i < l; i++) { track(arr, "get", i + ""); } const res = method.apply(arr, args); if (res === -1 || res === false) { return method.apply(arr, args.map(toRaw)); } else { return res; } }; }); ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { const method = Array.prototype[key]; arrayInstrumentations[key] = function(...args) { pauseTracking(); const res = method.apply(this, args); resetTracking(); return res; }; }); 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) : reactive2(res); } return res; }; } var set2 = /* @__PURE__ */ createSetter(); var shallowSet = /* @__PURE__ */ createSetter(true); 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: get2, set: set2, 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 shallowReactiveHandlers = extend({}, mutableHandlers, { get: shallowGet, set: shallowSet }); var shallowReadonlyHandlers = extend({}, readonlyHandlers, { get: shallowReadonlyGet }); var toReactive = (value) => isObject(value) ? reactive2(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; }; } var mutableInstrumentations = { 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) }; var shallowInstrumentations = { 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) }; var readonlyInstrumentations = { 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) }; var shallowReadonlyInstrumentations = { 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) }; var iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; iteratorMethods.forEach((method) => { mutableInstrumentations[method] = createIterableMethod(method, false, false); readonlyInstrumentations[method] = createIterableMethod(method, true, false); shallowInstrumentations[method] = createIterableMethod(method, false, true); shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); }); 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: createInstrumentationGetter(false, false) }; var shallowCollectionHandlers = { get: createInstrumentationGetter(false, true) }; var readonlyCollectionHandlers = { get: createInstrumentationGetter(true, false) }; var shallowReadonlyCollectionHandlers = { get: createInstrumentationGetter(true, true) }; 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 reactive2(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); } magic("nextTick", () => nextTick); magic("dispatch", (el) => dispatch.bind(dispatch, el)); magic("watch", (el, { evaluateLater: evaluateLater2, effect: effect3 }) => (key, callback) => { let evaluate2 = evaluateLater2(key); let firstTime = true; let oldValue; let effectReference = effect3(() => evaluate2((value) => { JSON.stringify(value); if (!firstTime) { queueMicrotask(() => { callback(value, oldValue); oldValue = value; }); } else { oldValue = value; } firstTime = false; })); el._x_effects.delete(effectReference); }); magic("store", getStores); magic("data", (el) => scope(el)); magic("root", (el) => closestRoot(el)); magic("refs", (el) => { if (el._x_refs_proxy) return el._x_refs_proxy; el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el)); return el._x_refs_proxy; }); function getArrayOfRefObject(el) { let refObjects = []; let currentEl = el; while (currentEl) { if (currentEl._x_refs) refObjects.push(currentEl._x_refs); currentEl = currentEl.parentNode; } return refObjects; } var globalIdMemo = {}; function findAndIncrementId(name) { if (!globalIdMemo[name]) globalIdMemo[name] = 0; return ++globalIdMemo[name]; } function closestIdRoot(el, name) { return findClosest(el, (element) => { if (element._x_ids && element._x_ids[name]) return true; }); } function setIdRoot(el, name) { if (!el._x_ids) el._x_ids = {}; if (!el._x_ids[name]) el._x_ids[name] = findAndIncrementId(name); } magic("id", (el) => (name, key = null) => { let root = closestIdRoot(el, name); let id = root ? root._x_ids[name] : findAndIncrementId(name); return key ? `${name}-${id}-${key}` : `${name}-${id}`; }); magic("el", (el) => el); warnMissingPluginMagic("Focus", "focus", "focus"); warnMissingPluginMagic("Persist", "persist", "persist"); function warnMissingPluginMagic(name, magicName, slug) { magic(magicName, (el) => warn(`You can't use [$${directiveName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el)); } function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) { let firstRun = true; let outerHash, innerHash, outerHashLatest, innerHashLatest; let reference = effect(() => { let outer, inner; if (firstRun) { outer = outerGet(); innerSet(outer); inner = innerGet(); firstRun = false; } else { outer = outerGet(); inner = innerGet(); outerHashLatest = JSON.stringify(outer); innerHashLatest = JSON.stringify(inner); if (outerHashLatest !== outerHash) { inner = innerGet(); innerSet(outer); inner = outer; } else { outerSet(inner); outer = inner; } } outerHash = JSON.stringify(outer); innerHash = JSON.stringify(inner); }); return () => { release(reference); }; } directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => { let func = evaluateLater2(expression); let innerGet = () => { let result; func((i) => result = i); return result; }; let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`); let innerSet = (val) => evaluateInnerSet(() => { }, { scope: { "__placeholder": val } }); let initialValue = innerGet(); innerSet(initialValue); queueMicrotask(() => { if (!el._x_model) return; el._x_removeModelListeners["default"](); let outerGet = el._x_model.get; let outerSet = el._x_model.set; let releaseEntanglement = entangle( { get() { return outerGet(); }, set(value) { outerSet(value); } }, { get() { return innerGet(); }, set(value) { innerSet(value); } } ); cleanup2(releaseEntanglement); }); }); var teleportContainerDuringClone = document.createElement("div"); directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => { if (el.tagName.toLowerCase() !== "template") warn("x-teleport can only be used on a