@pacem/pacem-core 1.0.0-abel

package/dist/esm/defaults.js

@@ -0,0 +1,5 @@
+//namespace Pacem {
+export const Defaults = {
+    USE_SHADOW_ROOT: /*'attachShadow' in Element.prototype &&*/ false /* <- wait until html-imports */
+};
+//}

package/dist/esm/events.js

@@ -0,0 +1,89 @@
+/// <reference path="utils-customevent.ts" />
+import { Utils } from './utils';
+import { CustomEventUtils } from './utils-customevent';
+// namespace Pacem {
+export class CustomTypedEvent extends CustomEvent /* new in TypeScript v2.7.1 -> */ {
+    constructor(type, detail, eventInit) {
+        super(type, Utils.extend({ detail: detail }, eventInit || {}));
+        CustomEventUtils.fixEdgeCustomEventSubClassInstance(this, this.constructor);
+    }
+}
+function isEventInit(obj) {
+    if ('detail' in obj) {
+        // must provide a detail
+        for (let prop in obj) {
+            if (prop !== 'bubbles' && prop !== 'cancelable' && prop !== 'composed' && prop !== 'detail') {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+// TODO: make inherit from CustomTypedEvent
+export class CustomUIEvent extends CustomEvent {
+    constructor(type, detail, eventInit, orig) {
+        super(type, Utils.extend((isEventInit(detail || {}) ? detail : { detail: detail }), (!(eventInit instanceof Event) && eventInit) || {}));
+        const originalEvent = orig || eventInit;
+        if (originalEvent instanceof Event) {
+            this.#originalEvent = originalEvent;
+            this.#modifiers = CustomEventUtils.getEventKeyModifiers(originalEvent);
+            if (originalEvent instanceof MouseEvent || originalEvent instanceof TouchEvent) {
+                this.#coords = CustomEventUtils.getEventCoordinates(originalEvent);
+            }
+        }
+        CustomEventUtils.fixEdgeCustomEventSubClassInstance(this, this.constructor);
+    }
+    #originalEvent;
+    #modifiers;
+    #coords;
+    get originalEvent() {
+        return this.#originalEvent;
+    }
+    get which() {
+        return this.#modifiers?.which;
+    }
+    get altKey() {
+        return this.#modifiers?.altKey;
+    }
+    get shiftKey() {
+        return this.#modifiers?.shiftKey;
+    }
+    get ctrlKey() {
+        return this.#modifiers?.ctrlKey;
+    }
+    get metaKey() {
+        return this.#modifiers?.metaKey;
+    }
+    get pageX() {
+        return this.#coords?.page.x;
+    }
+    get pageY() {
+        return this.#coords?.page.y;
+    }
+    get clientX() {
+        return this.#coords?.client.x;
+    }
+    get clientY() {
+        return this.#coords?.client.y;
+    }
+    get screenX() {
+        return this.#coords?.screen.x;
+    }
+    get screenY() {
+        return this.#coords?.screen.y;
+    }
+}
+export const AttributeChangeEventName = 'attributechange';
+export class AttributeChangeEvent extends CustomTypedEvent {
+    constructor(args) {
+        super(AttributeChangeEventName, args);
+    }
+}
+export const PropertyChangeEventName = 'propertychange';
+export class PropertyChangeEvent extends CustomTypedEvent {
+    constructor(args) {
+        super(PropertyChangeEventName, args);
+    }
+}
+//}

package/dist/esm/eventtarget.js

@@ -0,0 +1,131 @@
+/// <reference path="converters.ts" />
+/// <reference path="decorators.ts" />
+/// <reference path="logger.ts" />
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Expression } from './expression';
+import { LogLevel } from './logger';
+import { INSTANCE_SCOPE_VAR } from './types';
+import { Utils } from './utils';
+import { CustomElementUtils } from './utils-customelement';
+import { Watch } from './decorators';
+import { PropertyConverters } from './converters';
+//namespace Pacem.Components {
+export class PacemEventTarget extends HTMLElement {
+    constructor() {
+        super();
+        this._isReady = false;
+        this.emitHandler = (evt) => {
+            // no handlers processed if the element is disabled.
+            if (!this.disabled) {
+                this.emit(evt);
+            }
+        };
+    }
+    /**
+     * Executes the relevant handler defined in the `on-{evt.type}` attribute, if any.
+     * @param evt {Event} the event to be fired
+     */
+    emit(evt) {
+        if (evt.defaultPrevented) {
+            // skip if evt was canceled
+            return;
+        }
+        this._emitCore(evt);
+    }
+    _emitCore(evt) {
+        var attrName = `on-${evt.type.toLowerCase()}`;
+        if (attrName in this.attributes) {
+            this.log(LogLevel.Debug, `Calling ${attrName} handler for event ${evt.type}`);
+            var attrBody = this.attributes[attrName].value;
+            var expression = Expression.parse(attrBody, this);
+            if (!Utils.isNull(expression) && expression.pending !== true) {
+                expression.evaluatePlus({ '$event': evt });
+            }
+        }
+    }
+    handle(evt, detail) {
+        if (typeof evt === 'string') {
+            evt = Utils.isNull(detail) ? new Event(evt, { cancelable: false }) : new CustomEvent(evt, { cancelable: false, detail });
+        }
+        this.emit(evt);
+    }
+    /** Gets whether the element has been completely loaded alongside with the other pieces of the DOM. */
+    get isReady() {
+        return this._isReady;
+    }
+    connectedCallback() {
+        CustomElementUtils.setAttachedPropertyValue(this, INSTANCE_SCOPE_VAR, CustomElementUtils.findScopeContext(this));
+        this.log(LogLevel.Debug, `Connected.`);
+    }
+    disconnectedCallback() {
+        this._isReady = false;
+        this.dispatchEvent(new Event('unload'));
+        CustomElementUtils.deleteAttachedPropertyValue(this, INSTANCE_SCOPE_VAR);
+        this.log(LogLevel.Debug, `Disconnected.`);
+    }
+    viewActivatedCallback() {
+        this._isReady = true;
+        this.log(LogLevel.Debug, `Loaded (view activated).`);
+        this.dispatchEvent(new Event('load'));
+    }
+    /**
+     * Manages the value change of a watched property.
+     * @param name {string} property name
+     * @param old {any} former property value
+     * @param val {any} new/current property value
+     * @param first {boolean} whether is the first change (right before view activation) or not
+     */
+    propertyChangedCallback(name, old, val, first) {
+        if (first)
+            this.log(LogLevel.Log, `Property "${name}" changed at start-up`);
+        else
+            this.log(LogLevel.Log, `Property "${name}" changed from ${old} to ${val}`);
+    }
+    /**
+     * Wraps the native dispatchEvent in order to emit `on-{evt-type}` handler, if any.
+     * @param evt {Event} the event to be fired
+     */
+    dispatchEvent(evt) {
+        // no events dispatched if the element is disabled.
+        if (this.disabled) {
+            return false;
+        }
+        this.log(LogLevel.Log, `Dispatching event "${evt.type}"`);
+        const ret = super.dispatchEvent(evt);
+        this.emit(evt);
+        return ret;
+    }
+    /**
+     * Logs a message if a logger is available.
+     * @param level {LogLevel} Level of log
+     * @param message {String} Content
+     * @param category {String} Grouping category
+     */
+    log(level, message, category = this.localName + (this.id ? '#' + this.id : '')) {
+        this.logger && typeof this.logger.log === 'function' && this.logger.log(level, message, category);
+    }
+    /** Refreshes all the properties corresponding to explicit binding attributes. */
+    refreshBindings() {
+        // refresh all the bindings
+        for (let j = 0; j < this.attributes.length; j++) {
+            let attr = this.attributes.item(j), isBinding = CustomElementUtils.isBindingAttribute(attr.value);
+            if (!isBinding)
+                continue;
+            let prop = CustomElementUtils.kebabToCamel(attr.name);
+            let binding = CustomElementUtils.parseBindingAttribute(attr.value, this);
+            this[prop] = binding.evaluate();
+        }
+    }
+}
+__decorate([
+    Watch({ reflectBack: true, converter: PropertyConverters.Boolean })
+], PacemEventTarget.prototype, "disabled", void 0);
+__decorate([
+    Watch({ emit: false, converter: PropertyConverters.Element })
+], PacemEventTarget.prototype, "logger", void 0);
+//}

package/dist/esm/expression.js

@@ -0,0 +1,228 @@
+/// <reference path="types.ts" />
+/// <reference path="utils.ts" />
+/// <reference path="utils-customelement.ts" />
+import { DeferPromise } from './promise';
+import { Utils } from './utils';
+import { CustomElementUtils, Repeater } from './utils-customelement';
+const CONTEXT_PREFIX = '__context_pacem';
+/** the following pattern matches:
+ * -------------------------------
+ * ciao "a tutti \"quanti\" voi"                                    -> "a tutti \"quanti\" voi"
+ * ciao 'a tutti "quanti" voi'+ mysel.value + 'e a nessun\' altra'  -> 'a tutti "quanti" voi'
+ *                                                                     'e a nessun\' altra'
+ */
+const stringPattern = /'(\\'|[^'])*[^\\]?'|"(\\"|[^"])*[^\\]?"/g;
+/** the following pattern matches:
+ * -------------------------------
+ * var l = new Date();  ->  new
+ * window.eval(         -> window.
+ * eval(                -> eval(
+ * eval  (              -> eval  (
+ */
+const safetyPattern = /[^\w]new\s|[^\w]window\s*[\.\[]|[^\w]document\s*\.|[^\w]eval\s*\(/;
+/** the following pattern matches:
+ * -------------------------------
+ * ^^^item.ciao           -> ^^^item
+ * !ciao.value            -> !ciao.
+ * :host.value            -> :host.
+ * ::child.prop           -> ::child.
+ * _connectTo(me.value)   -> (me.
+ * 009.ciao               ->
+ * this[that.value]       -> [that.
+ */
+const variablePattern = /(^|[\s\(\[\+\-\*\/!])(:host\.|\^+item[\s\.,;\)\]]|\^+item$|\^+index[^\w\.]|\^+index$|\$?this[\.\s$]?|#[a-zA-Z_][\w]*|::[a-zA-Z_][\w]*)/g;
+///** the following pattern tests:
+// * -------------------------------
+// * __context.$this.myself.value -> true
+// * !__context.myelem.value      -> false
+// * fn(myelem.value)             -> false
+// * $this == that                -> false
+// * ...
+// */
+//const purePropertyPathPattern = /^[\w\.\$]+/; 
+export class Expression {
+    constructor() {
+        this._pending = false;
+        this._independent = false;
+    }
+    get dependencies() {
+        return this._dependencies;
+    }
+    get functionBody() {
+        return this._fnBody;
+    }
+    get voidBody() {
+        return this._voidBody;
+    }
+    get pending() {
+        return this._pending;
+    }
+    get independent() {
+        return this._independent;
+    }
+    evaluate() {
+        if (!this._fn) {
+            this._fn = new Function('$pacem', CONTEXT_PREFIX, this._fnBody);
+        }
+        return this._fn.apply(null, [Utils.core, this._args]);
+    }
+    evaluateAsync() {
+        const deferred = DeferPromise.defer();
+        if (!this._fn) {
+            this._fn = new Function('$pacem', CONTEXT_PREFIX, this._fnBody);
+        }
+        deferred.resolve(this._fn.apply(null, [Utils.core, this._args]));
+        return deferred.promise;
+    }
+    evaluatePlus(args = {}) {
+        if (!this._fn) {
+            let argNames = [CONTEXT_PREFIX];
+            for (var prop in args)
+                argNames.push(prop);
+            argNames.push('$pacem');
+            this._fn = new Function(argNames.join(', '), this._voidBody);
+        }
+        let argValues = [].concat(this._args);
+        for (var prop in args)
+            argValues.push(args[prop]);
+        argValues.push(Utils.core);
+        return this._fn.apply(null, argValues);
+    }
+    static { this._pendingExpression = null; }
+    static _getPendingExpressionSingleton() {
+        if (Expression._pendingExpression == null) {
+            let xpr = new Expression();
+            xpr._pending = true;
+            xpr._dependencies = [];
+            Expression._pendingExpression = xpr;
+        }
+        return Expression._pendingExpression;
+    }
+    static parse(expression, element) {
+        var context = CustomElementUtils.findScopeContext(element);
+        var args = { '$this': element };
+        var dependencies = [];
+        var expr = '';
+        var independent = true;
+        //1. remove strings
+        var strings = [], stringMatches, index = 0, trunks = [];
+        while ((stringMatches = stringPattern.exec(expression)) != null) {
+            trunks.push(expression.substr(index, stringMatches.index - index));
+            let length = stringMatches[0].length;
+            strings.push({ start: stringMatches.index, length: length });
+            index = stringMatches.index + length;
+        }
+        if (index < expression.length)
+            trunks.push(expression.substr(index, expression.length - index));
+        //2. loop non string trunks
+        // trunks.length >= strings.length (more precisely, the following statemente is always `true`:
+        // trunks.length === strings.length || trunks.length === strings.length+1;
+        for (var j = 0; j < trunks.length; j++) {
+            let trunk = trunks[j];
+            if (safetyPattern.test(trunk))
+                throw `Unsafe expression detected: "${trunk}".`;
+            if (context == null) {
+                // context is null, means viewActivated event still to be fired.
+                // check whether this is a constant expression (then no need to instantiate actual binding listeners)
+                // or not.
+                if (new RegExp(variablePattern).test(trunk) === true) {
+                    independent = false;
+                    break;
+                }
+            }
+            else {
+                let processedTrunk = trunk.replace(variablePattern, (mwhole, mstart, melem, index, input) => {
+                    independent = false;
+                    const cmpRef = `__host_pacem`;
+                    // default initialization := assumes `this`
+                    let retval = CONTEXT_PREFIX + '.$this' + (melem.endsWith('.') ? '.' : ''), el = element, dotIndex = input.indexOf('.', index), furtherParts = dotIndex > index ? input.substr(dotIndex + 1).trim() : '', pathRegexArray = /^[\w\.\$]+/.exec(furtherParts), path = pathRegexArray && pathRegexArray.length > 0 && pathRegexArray[0], propArray, prop = path && (propArray = path.split('.')).length > 0 && propArray[0];
+                    if (melem === ':host.') {
+                        el = args[cmpRef] = args[cmpRef] || CustomElementUtils.findHostContext(element);
+                        retval = `${CONTEXT_PREFIX}.${cmpRef}.`;
+                    }
+                    else if (melem.endsWith('^item') || melem.substr(0, melem.length - 1).endsWith('^item')) {
+                        let lastChar = melem.endsWith('^item') ? '' : melem.substr(melem.length - 1, 1);
+                        let upLevels = melem.length - (lastChar.length > 0 ? 6 : 5); // 5 = 'item'.length + 1 (zero-based)
+                        let itemRef = `__item_${upLevels}_up_pacem`;
+                        let item = Repeater.findItemContext(element, upLevels);
+                        el = args[itemRef] = args[itemRef] || (item && item.placeholder);
+                        path = 'item' + (path ? ('.' + path) : '');
+                        prop = 'item';
+                        retval = `${CONTEXT_PREFIX}.${itemRef}.item${lastChar}`;
+                    }
+                    else if (melem.endsWith('^index') || melem.substr(0, melem.length - 1).endsWith('^index')) {
+                        let lastChar = melem.endsWith('^index') ? '' : melem.substr(melem.length - 1, 1);
+                        let upLevels = melem.length - (lastChar.length > 0 ? 7 : 6); // 6 = 'index'.length + 1 (zero-based)
+                        let itemRef = `__item_${upLevels}_up_pacem`;
+                        let item = Repeater.findItemContext(element, upLevels);
+                        el = args[itemRef] = args[itemRef] || (item && item.placeholder);
+                        path = 'index';
+                        prop = 'index';
+                        retval = `${CONTEXT_PREFIX}.${itemRef}.index${lastChar}`;
+                    }
+                    else if (melem.startsWith('::')) {
+                        let melem0 = melem.substr(2, melem.length - 2);
+                        let host = args[cmpRef] = args[cmpRef] || CustomElementUtils.findHostContext(element);
+                        if (!Utils.isNull(host)) {
+                            el = host[melem0];
+                        }
+                        else {
+                            el = null;
+                        }
+                        retval = `${CONTEXT_PREFIX}.${cmpRef}.${melem0}`;
+                    }
+                    else if (melem.startsWith('#')) {
+                        let melem0 = melem.substr(1, melem.length - 1);
+                        el = args[melem0] = args[melem0] || context.querySelector('#' + melem0);
+                        retval = `${CONTEXT_PREFIX}.${melem0}`;
+                    }
+                    // merge dependencies
+                    if (prop && el && prop in el
+                        // && it is not a direct method call (which means that the 'prop' isn't in fact a 'func')
+                        && typeof el[prop] !== 'function' //!isMethodCall 
+                        // && does not already exist as a dependency
+                        && dependencies.find(d => d.element === el && d.property == prop) == null) {
+                        dependencies.push({ element: el, property: prop, path: path, twowayAllowed: false });
+                    }
+                    // return value
+                    return mstart + retval;
+                });
+                expr += processedTrunk;
+                if (j < strings.length) {
+                    const s = strings[j];
+                    expr += expression.substr(s.start, s.length);
+                }
+            }
+        }
+        if (independent) {
+            // constant expression
+            var constexpr = new Expression();
+            constexpr._independent = true;
+            constexpr._fnBody = `return ${expression};`;
+            constexpr._voidBody = expression;
+            constexpr._dependencies = [];
+            return constexpr;
+        }
+        if (context == null) {
+            return this._getPendingExpressionSingleton();
+        }
+        // if some dependency elements aren't available yet, then postpone...
+        for (var elem in args) {
+            if (args[elem] == null)
+                return Expression._getPendingExpressionSingleton();
+        }
+        if (dependencies.length == 1
+            // := && trimmed expression contains only letters, figures, underscores, dots, and '$'...
+            && /[^\w\.\$]+/.test(expr.trim()) !== true) {
+            // ...then 'twoway' binding might be applied/accepted
+            dependencies[0].twowayAllowed = true;
+        }
+        var retexpr = new Expression();
+        retexpr._args = args;
+        retexpr._fnBody = `try{ var ___$$$r = ${expr}; return ___$$$r; }catch(e){  }`;
+        retexpr._voidBody = `try{ ${expr} }catch(e){  }`;
+        retexpr._dependencies = dependencies;
+        return retexpr;
+    }
+}
+// }

package/dist/esm/index-animations.js

@@ -0,0 +1 @@
+export * from './animations';

package/dist/esm/index-behaviors.js

@@ -0,0 +1 @@
+export * from './components/index.behaviors';

package/dist/esm/index-components.js

@@ -0,0 +1 @@
+export * from './components';

package/dist/esm/index-iife.js

@@ -0,0 +1,3 @@
+import { DeepMerger } from '@pacem/pacem-foundation';
+import * as Output from './index';
+DeepMerger.merge(Output);

package/dist/esm/index-logging.js

@@ -0,0 +1 @@
+export * from './logger';

package/dist/esm/index-net.js

@@ -0,0 +1 @@
+export * from './net';

package/dist/esm/index-root.js

@@ -0,0 +1,20 @@
+export * from './trees';
+export * from './utils';
+export * from './utils-customelement';
+export * from './utils-customevent';
+export * from './adapter';
+export * from './command';
+export * from './comparers';
+export * from './converters';
+export * from './decorators';
+export * from './defaults';
+export * from './events';
+export * from './eventtarget';
+export * from './expression';
+export * from './prefix';
+export * from './promise';
+export * from './regex';
+export * from './storage';
+export * from './template';
+export * from './transforms';
+export * from './types';

package/dist/esm/index-ui.js

@@ -0,0 +1 @@
+export * from './ui';

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export * as Animations from './index-animations';
+export * as Net from './index-net';
+export * as UI from './index-ui';
+export * as Components from './index-components';
+export * as Behaviors from './index-behaviors';
+export * as Logging from './index-logging';
+export * from './index-root';

package/dist/esm/logger.js

@@ -0,0 +1,11 @@
+//namespace Pacem.Logging {
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["Trace"] = "trace";
+    LogLevel["Debug"] = "debug";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+    LogLevel["Info"] = "info";
+    LogLevel["Log"] = "log";
+})(LogLevel || (LogLevel = {}));
+//}

package/dist/esm/prefix.js

@@ -0,0 +1,6 @@
+//namespace Pacem {
+var root;
+/** the overall customelement prefix */
+export const P = (root = window['Pacem'])?.Configuration?.prefix ?? 'pacem';
+export const PCSS = root?.Configuration?.css ?? P;
+//}

package/dist/esm/promise.js

@@ -0,0 +1,34 @@
+//namespace Pacem {
+export class DeferPromise {
+    constructor() {
+        this.deferred = null;
+        var me = this;
+        me.promise = new Promise(function (resolve, reject) {
+            me.deferred = { 'resolve': resolve, 'reject': reject, 'promise': me };
+        });
+    }
+    then(onCompleted, onFailed) {
+        return this.promise.then(onCompleted, onFailed);
+    }
+    /**
+     * Occurs whenever the promise concludes (either after completion or error).
+     * @param {Function } callback
+     */
+    finally(callback) {
+        this.promise.then(callback, callback);
+        return this;
+    }
+    success(callback) {
+        this.promise.then(callback, null);
+        return this;
+    }
+    error(callback) {
+        this.promise.then(null, callback);
+        return this;
+    }
+    static defer() {
+        var q = new DeferPromise();
+        return q.deferred;
+    }
+}
+//}

package/dist/esm/regex.js

@@ -0,0 +1,22 @@
+//namespace Pacem.RegularExpressions {
+export const EMPTY_MATCHER = /a^/;
+export class Regex {
+    /**
+     * Splits an input string into segments based on a matching pattern.
+     * @param input Input string
+     * @param pattern RegExp pattern
+     */
+    static split(input, pattern) {
+        var matches, index = 0, trunks = [];
+        while ((matches = pattern.exec(input)) != null) {
+            trunks.push({ value: input.substr(index, matches.index - index), match: false, index: index });
+            let length = matches[0].length;
+            trunks.push({ value: input.substr(matches.index, length), match: true, index: matches.index });
+            index = matches.index + length;
+        }
+        if (index < input.length)
+            trunks.push({ value: input.substr(index, input.length - index), match: false, index: index });
+        return trunks;
+    }
+}
+//}

package/dist/esm/storage.js

@@ -0,0 +1,56 @@
+import { Utils } from './utils';
+//namespace Pacem {
+const EXPIRATION_FIELD = '_exp';
+export class Storage {
+    _getStorage(persistent) {
+        return !!persistent ? window.localStorage : window.sessionStorage;
+    }
+    _parseValue(storage, name) {
+        const value = storage.getItem(name);
+        if (Utils.isNullOrEmpty(value)) {
+            return null;
+        }
+        const output = Utils.Json.parse(value);
+        if (!Object.hasOwnProperty(EXPIRATION_FIELD)) {
+            return output;
+        }
+        const exp = output[EXPIRATION_FIELD];
+        if (exp < Date.now()) {
+            storage.removeItem(name);
+            return null;
+        }
+        return output['value'];
+    }
+    setPropertyValue(name, value, persistent) {
+        var storage = this._getStorage(persistent === true || (typeof persistent === 'number' && persistent > 0));
+        var storedValue = value;
+        // set cache timeout
+        if (typeof persistent === 'number' && persistent > 0) {
+            const exp = Date.now() + 1000 * persistent;
+            storedValue = { value: value };
+            storedValue[EXPIRATION_FIELD] = exp;
+        }
+        storage.setItem(name, Utils.Json.stringify(storedValue));
+        // delete omonymy
+        storage = this._getStorage(!persistent);
+        storage.removeItem(name);
+    }
+    getPropertyValue(name) {
+        return this._parseValue(this._getStorage(false), name)
+            || this._parseValue(this._getStorage(true), name);
+    }
+    clear() {
+        var storage = this._getStorage(true);
+        storage.clear();
+        storage = this._getStorage(false);
+        storage.clear();
+    }
+    ;
+    removeProperty(name) {
+        var storage = this._getStorage(true);
+        storage.removeItem(name);
+        storage = this._getStorage(false);
+        storage.removeItem(name);
+    }
+}
+//}

package/dist/esm/template.js

@@ -0,0 +1,4 @@
+//namespace Pacem {
+export class TemplateElement extends HTMLElement {
+}
+//}