@microsoft/fast-html 1.0.0-alpha.30 → 1.0.0-alpha.32

package/dist/dts/components/observer-map.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from "./schema.js";
+import type { Schema } from "./schema.js";
 /**
  * ObserverMap provides functionality for caching binding paths, extracting root properties,
  * and defining observable properties on class prototypes

package/dist/dts/components/schema.d.ts

@@ -1,4 +1,4 @@
-import { type ChildrenMap } from "./utilities.js";
+import type { ChildrenMap } from "./utilities.js";
 type FastContextMetaData = "$fast_context";
 type FastContextsMetaData = "$fast_parent_contexts";
 export interface JSONSchemaDefinition extends JSONSchemaCommon {

package/dist/dts/components/utilities.d.ts

@@ -1,4 +1,4 @@
-import { JSONSchema, JSONSchemaDefinition, Schema } from "./schema.js";
+import { type JSONSchema, type JSONSchemaDefinition, Schema } from "./schema.js";
 type BehaviorType = "dataBinding" | "templateDirective";
 type TemplateDirective = "when" | "repeat";
 export type AttributeDirective = "children" | "slotted" | "ref";
@@ -40,6 +40,24 @@ export interface ChildrenMap {
     customElementName: string;
     attributeName: string;
 }
+declare const LogicalOperator: {
+    AND: string;
+    OR: string;
+};
+type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+declare const Operator: {
+    readonly ACCESS: "access";
+    readonly EQUALS: "==";
+    readonly GREATER_THAN: ">";
+    readonly GREATER_THAN_OR_EQUALS: ">=";
+    readonly LESS_THAN: "<";
+    readonly LESS_THAN_OR_EQUALS: "<=";
+    readonly NOT: "!";
+    readonly NOT_EQUALS: "!=";
+    readonly AND: string;
+    readonly OR: string;
+};
+type Operator = (typeof Operator)[keyof typeof Operator];
 /**
  * Get the index of the next matching tag
  * @param openingTagStartSlice - The slice starting from the opening tag
@@ -71,22 +89,6 @@ export declare function expressionResolver(rootPropertyName: string | null, expr
  * @returns A Set containing all unique paths found in the expression chain
  */
 export declare function extractPathsFromChainedExpression(chainedExpression: ChainedExpression): Set<string>;
-/**
- * Available operators include:
- *
- * - access (no operator)
- * - not (!)
- * - equals (==)
- * - not equal (!=)
- * - greater than or equal (>=)
- * - greater than (>)
- * - less than or equal (<=)
- * - less than (<)
- * - or (||)
- * - and (&&) and the HTML character entity (&amp;&amp;)
- */
-type Operator = "access" | "!" | "==" | "!=" | ">=" | ">" | "<=" | "<";
-type ChainingOperator = "||" | "&&" | "&amp;&amp;";
 interface Expression {
     operator: Operator;
     left: string;
@@ -95,7 +97,7 @@ interface Expression {
     rightIsValue: boolean | null;
 }
 export interface ChainedExpression {
-    operator?: ChainingOperator;
+    operator?: LogicalOperator;
     expression: Expression;
     next?: ChainedExpression;
 }

package/dist/esm/components/utilities.js

@@ -14,6 +14,21 @@ const startInnerHTMLDiv = `<div :innerHTML="{{`;
 const startInnerHTMLDivLength = startInnerHTMLDiv.length;
 const endInnerHTMLDiv = `}}"></div>`;
 const endInnerHTMLDivLength = endInnerHTMLDiv.length;
+const LogicalOperator = {
+    AND: "&&",
+    OR: "||",
+};
+const ComparisonOperator = {
+    ACCESS: "access",
+    EQUALS: "==",
+    GREATER_THAN: ">",
+    GREATER_THAN_OR_EQUALS: ">=",
+    LESS_THAN: "<",
+    LESS_THAN_OR_EQUALS: "<=",
+    NOT: "!",
+    NOT_EQUALS: "!=",
+};
+const Operator = Object.assign(Object.assign({}, LogicalOperator), ComparisonOperator);
 /**
  * A map of proxied objects
  */
@@ -307,6 +322,22 @@ export function bindingResolver(previousString, rootPropertyName, path, parentCo
     return pathResolver(path, currentContext, level, schema.getSchema(rootPropertyName));
 }
 export function expressionResolver(rootPropertyName, expression, parentContext, level, schema) {
+    // Extract all paths from the expression and add them to the schema
+    if (rootPropertyName !== null) {
+        const paths = extractPathsFromChainedExpression(expression);
+        paths.forEach(path => {
+            schema.addPath({
+                pathConfig: {
+                    type: "access",
+                    currentContext: parentContext,
+                    parentContext: null,
+                    path,
+                },
+                rootPropertyName,
+                childrenMap: null,
+            });
+        });
+    }
     return (x, c) => resolveChainedExpression(x, c, level, parentContext || null, expression, schema.getSchema(rootPropertyName));
 }
 /**
@@ -384,17 +415,19 @@ function evaluatePartsInExpressionChain(parts, operator) {
  * @returns - A configuration object containing information about the expression
  */
 export function getExpressionChain(value) {
+    // Decode HTML entities in the expression value first
+    const decodedValue = decodeExpressionOperators(value);
     // Handle operator precedence: || has lower precedence than &&
     // First, split by || (lowest precedence)
-    const orParts = value.split(" || ");
+    const orParts = decodedValue.split(/\s*\|\|\s*/);
     if (orParts.length > 1) {
-        const firstPart = evaluatePartsInExpressionChain(orParts, "||");
+        const firstPart = evaluatePartsInExpressionChain(orParts, Operator.OR);
         if (firstPart) {
             return firstPart;
         }
     }
     // If no ||, check for && (higher precedence)
-    const andParts = value.split(" && ");
+    const andParts = decodedValue.split(/\s*&&\s*/);
     if (andParts.length > 1) {
         // Process each part recursively and chain them with &&
         const firstPart = evaluatePartsInExpressionChain(andParts, "&&");
@@ -402,19 +435,10 @@ export function getExpressionChain(value) {
             return firstPart;
         }
     }
-    // Handle HTML entity version of &&
-    const ampParts = value.split(" &amp;&amp; ");
-    if (ampParts.length > 1) {
-        // Process each part recursively and chain them with &amp;&amp;
-        const firstPart = evaluatePartsInExpressionChain(ampParts, "&amp;&amp;");
-        if (firstPart) {
-            return firstPart;
-        }
-    }
     // No chaining operators found, create a single expression
-    if (value.trim()) {
+    if (decodedValue.trim()) {
         return {
-            expression: getExpression(value.trim()),
+            expression: getExpression(decodedValue.trim()),
         };
     }
     return void 0;
@@ -425,18 +449,18 @@ export function getExpressionChain(value) {
  * @returns An Expression object containing the operator, operands, and whether operands are literal values
  */
 function getExpression(value) {
-    if (value[0] === "!") {
+    if (value[0] === Operator.NOT) {
         const left = value.slice(1);
         const operandValue = isOperandValue(left);
         return {
-            operator: "!",
+            operator: Operator.NOT,
             left,
             leftIsValue: operandValue.isValue,
             right: null,
             rightIsValue: null,
         };
     }
-    const split = value.split(" ");
+    const split = value.split(/\s*([=!]=|[><]=?)\s*/);
     if (split.length === 3) {
         const operator = split[1];
         const right = split[2];
@@ -452,13 +476,26 @@ function getExpression(value) {
         };
     }
     return {
-        operator: "access",
+        operator: Operator.ACCESS,
         left: value,
         leftIsValue: false,
         right: null,
         rightIsValue: null,
     };
 }
+/**
+ * Decodes HTML entities within expression strings only (for operators like &&, <, >)
+ * This is safer than decoding the entire template as it preserves HTML-encoded content
+ * and only decodes operators needed for expression evaluation
+ * @param expression - The expression string to decode
+ * @returns The expression with operators decoded
+ */
+function decodeExpressionOperators(expression) {
+    return expression
+        .replace(/&amp;&amp;/g, Operator.AND)
+        .replace(/&lt;/g, Operator.LESS_THAN)
+        .replace(/&gt;/g, Operator.GREATER_THAN);
+}
 /**
  * Resolve a single expression by evaluating its operator and operands
  * @param x - The current data context
@@ -471,41 +508,36 @@ function getExpression(value) {
  */
 function resolveExpression(x, c, level, contextPath, expression, rootSchema) {
     const { operator, left, right, rightIsValue } = expression;
+    const resolvedLeft = pathResolver(left, contextPath, level, rootSchema)(x, c);
+    let resolvedRight = right;
+    if (!rightIsValue && typeof right === "string") {
+        resolvedRight = pathResolver(right, contextPath, level, rootSchema)(x, c);
+    }
     switch (operator) {
-        case "!":
-            return !pathResolver(left, contextPath, level, rootSchema)(x, c);
-        case "==":
-            return (pathResolver(left, contextPath, level, rootSchema)(x, c) ==
-                (rightIsValue
-                    ? right
-                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
-        case "!=":
-            return (pathResolver(left, contextPath, level, rootSchema)(x, c) !=
-                (rightIsValue
-                    ? right
-                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
-        case ">=":
-            return (pathResolver(left, contextPath, level, rootSchema)(x, c) >=
-                (rightIsValue
-                    ? right
-                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
-        case ">":
-            return (pathResolver(left, contextPath, level, rootSchema)(x, c) >
-                (rightIsValue
-                    ? right
-                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
-        case "<=":
-            return (pathResolver(left, contextPath, level, rootSchema)(x, c) <=
-                (rightIsValue
-                    ? right
-                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
-        case "<":
-            return (pathResolver(left, contextPath, level, rootSchema)(x, c) <
-                (rightIsValue
-                    ? right
-                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
-        default:
-            return pathResolver(left, contextPath, level, rootSchema)(x, c);
+        case Operator.NOT: {
+            return !resolvedLeft;
+        }
+        case Operator.EQUALS: {
+            return resolvedLeft == resolvedRight;
+        }
+        case Operator.NOT_EQUALS: {
+            return resolvedLeft != resolvedRight;
+        }
+        case Operator.GREATER_THAN_OR_EQUALS: {
+            return resolvedLeft >= resolvedRight;
+        }
+        case Operator.GREATER_THAN: {
+            return resolvedLeft > resolvedRight;
+        }
+        case Operator.LESS_THAN_OR_EQUALS: {
+            return resolvedLeft <= resolvedRight;
+        }
+        case Operator.LESS_THAN: {
+            return resolvedLeft < resolvedRight;
+        }
+        default: {
+            return resolvedLeft;
+        }
     }
 }
 /**
@@ -519,18 +551,20 @@ function resolveExpression(x, c, level, contextPath, expression, rootSchema) {
  * @returns The resolved boolean result of the chained expression
  */
 function resolveChainedExpression(x, c, level, contextPath, expression, rootSchema) {
-    if (expression.next) {
-        switch (expression.next.operator) {
-            case "&&":
-            case "&amp;&amp;":
-                return (resolveExpression(x, c, level, contextPath, expression.expression, rootSchema) &&
-                    resolveChainedExpression(x, c, level, contextPath, expression.next, rootSchema));
-            case "||":
-                return (resolveExpression(x, c, level, contextPath, expression.expression, rootSchema) ||
-                    resolveChainedExpression(x, c, level, contextPath, expression.next, rootSchema));
+    const { expression: expr, next } = expression;
+    const resolvedLeft = resolveExpression(x, c, level, contextPath, expr, rootSchema);
+    if (next) {
+        const resolvedRight = resolveChainedExpression(x, c, level, contextPath, next, rootSchema);
+        switch (next.operator) {
+            case Operator.AND: {
+                return resolvedLeft && resolvedRight;
+            }
+            case Operator.OR: {
+                return resolvedLeft || resolvedRight;
+            }
         }
     }
-    return resolveExpression(x, c, level, contextPath, expression.expression, rootSchema);
+    return resolvedLeft;
 }
 /**
  * This is the transform utility for rationalizing declarative HTML syntax
@@ -625,7 +659,7 @@ function getSchemaProperties(schema) {
  * @param rootSchema - The root schema for the entire data structure
  * @returns The array with observable properties and change notifications
  */
-function assignObservablesToArray(proxiedData, schema, rootSchema) {
+function assignObservablesToArray(proxiedData, schema, rootSchema, target, rootProperty) {
     const data = proxiedData.map((item) => {
         const originalItem = Object.assign({}, item);
         assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
@@ -639,8 +673,10 @@ function assignObservablesToArray(proxiedData, schema, rootSchema) {
                         const item = subject[arg.index + i];
                         const originalItem = Object.assign({}, item);
                         assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
-                        return Object.assign(item, originalItem);
+                        Object.assign(item, originalItem);
                     }
+                    // Notify observers of the target object's root property
+                    Observable.notify(target, rootProperty);
                 }
             });
         },
@@ -714,11 +750,11 @@ export function assignObservables(schema, rootSchema, data, target, rootProperty
         case "array": {
             const context = findDef(schema);
             if (context) {
-                proxiedData = assignObservablesToArray(proxiedData, (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context], rootSchema);
+                proxiedData = assignObservablesToArray(proxiedData, (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context], rootSchema, target, rootProperty);
                 if (!observedArraysMap.has(proxiedData)) {
                     observedArraysMap.set(proxiedData, assignSubscribeToObservableArray(proxiedData, () => {
                         var _a;
-                        return assignObservablesToArray(proxiedData, (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context], rootSchema);
+                        return assignObservablesToArray(proxiedData, (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context], rootSchema, target, rootProperty);
                     }));
                 }
             }
@@ -741,20 +777,29 @@ export function assignObservables(schema, rootSchema, data, target, rootProperty
 function assignProxyToItemsInArray(proxiableItem, originalItem, schema, rootSchema) {
     const schemaProperties = getSchemaProperties(schema);
     getObjectProperties(proxiableItem, schemaProperties).forEach(key => {
-        Observable.defineProperty(proxiableItem, key);
+        // Initialize the property as undefined if it doesn't exist
+        if (!(key in originalItem)) {
+            originalItem[key] = undefined;
+        }
+        // Assign the proxy first
         originalItem[key] = assignProxyToItemsInObject(proxiableItem, key, originalItem[key], schemaProperties[key], rootSchema);
+        // Then make the property observable
+        Observable.defineProperty(proxiableItem, key);
     });
 }
 /**
  * Get an objects properties as agreed upon between the schema and data
  * @param data - The data
  * @param schemaProperties - The schema properties
- * @returns A list of strings the schema properties enumerate and is present in the data
+ * @returns A list of strings the schema properties enumerate (includes properties not present in data)
  */
 function getObjectProperties(data, schemaProperties) {
     const dataKeys = Object.keys(data);
     const schemaPropertyKeys = Object.keys(schemaProperties !== null && schemaProperties !== void 0 ? schemaProperties : {});
-    return dataKeys.filter(function (key) {
+    // Return all schema properties that are either in the data or in the schema
+    // This ensures properties defined in schema but missing from data get initialized
+    const allKeys = new Set([...dataKeys, ...schemaPropertyKeys]);
+    return Array.from(allKeys).filter(function (key) {
         return schemaPropertyKeys.indexOf(key) !== -1;
     });
 }
@@ -787,9 +832,9 @@ function assignProxyToItemsInObject(target, rootProperty, data, schema, rootSche
         if (context) {
             const definition = (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context];
             if ((definition === null || definition === void 0 ? void 0 : definition.type) === "object") {
-                proxiedData = assignObservablesToArray(proxiedData, definition, rootSchema);
+                proxiedData = assignObservablesToArray(proxiedData, definition, rootSchema, target, rootProperty);
                 if (!observedArraysMap.has(proxiedData)) {
-                    observedArraysMap.set(proxiedData, assignObservablesToArray(proxiedData, definition, rootSchema));
+                    observedArraysMap.set(proxiedData, assignObservablesToArray(proxiedData, definition, rootSchema, target, rootProperty));
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/fast-html",
-  "version": "1.0.0-alpha.30",
+  "version": "1.0.0-alpha.32",
   "type": "module",
   "author": {
     "name": "Microsoft",
@@ -21,35 +21,25 @@
     "./rules/*.yml"
   ],
   "scripts": {
-    "clean": "tsc -b --clean src",
-    "clean:dist": "node ../../../build/clean.js dist",
-    "build": "tsc -b src && npm run doc",
-    "build:attribute": "webpack --config ./src/fixtures/attribute/webpack.config.js",
-    "build:event": "webpack --config ./src/fixtures/event/webpack.config.js",
-    "build:binding": "webpack --config ./src/fixtures/binding/webpack.config.js",
-    "build:children": "webpack --config ./src/fixtures/children/webpack.config.js",
-    "build:dot-syntax": "webpack --config ./src/fixtures/dot-syntax/webpack.config.js",
-    "build:when": "webpack --config ./src/fixtures/when/webpack.config.js",
-    "build:ref": "webpack --config ./src/fixtures/ref/webpack.config.js",
-    "build:repeat": "webpack --config ./src/fixtures/repeat/webpack.config.js",
-    "build:observer-map": "webpack --config ./src/fixtures/observer-map/webpack.config.js",
-    "build:slotted": "webpack --config ./src/fixtures/slotted/webpack.config.js",
-    "build:lifecycle-callbacks": "webpack --config ./src/fixtures/lifecycle-callbacks/webpack.config.js",
-    "build-app": "npm run build:attribute && npm run build:dot-syntax && npm run build:event && npm run build:children && npm run build:binding && npm run build:when && npm run build:ref && npm run build:repeat && npm run build:observer-map && npm run build:slotted && npm run build:lifecycle-callbacks",
-    "build-server": "tsc -b server",
-    "doc": "api-extractor run --local",
+    "build:tsc": "tsc -p ./tsconfig.json",
+    "build": "npm run build:tsc && npm run doc",
+    "clean": "rimraf dist temp test-results",
+    "dev:full": "concurrently -k -n fast-element,fast-html,server \"npm run dev --workspace=@microsoft/fast-element\" \"npm:watch\" \"npm:test-server\"",
+    "dev": "concurrently -k -n tsc,server \"npm run watch\" \"npm run test-server\"",
     "doc:ci": "api-extractor run",
+    "doc": "npm run doc:ci -- --local",
+    "eslint:fix": "npm run eslint -- --fix",
     "eslint": "eslint . --ext .ts",
-    "eslint:fix": "eslint . --ext .ts --fix",
+    "install-playwright-browsers": "npm run playwright install",
     "prepublishOnly": "npm run clean && npm run build",
-    "pretest": "npm run build && npm run build-server",
     "prettier:diff": "prettier --config ../../../.prettierrc \"**/*.{ts,html}\" --list-different",
     "prettier": "prettier --config ../../../.prettierrc --write \"**/*.{ts,html}\"",
-    "test": "npm run build-app && playwright test && npm run test:rules",
-    "test-server": "node server/dist/server.js",
+    "test-server": "npx vite test/ --clearScreen false",
+    "test:playwright": "playwright test",
     "test:rules": "sg test --skip-snapshot-tests",
-    "install-playwright-browsers": "npm run playwright install",
-    "dev": "npm run build && npm run build-app && npm run build-server && npm run test-server"
+    "test": "npm run test:playwright && npm run test:rules",
+    "test:ui": "concurrently -k -n fast-element,fast-html,playwright \"npm run dev --workspace=@microsoft/fast-element\" \"npm:watch\" \"npx playwright test --ui\"",
+    "watch": "npm run build:tsc -- -w --preserveWatchOutput"
   },
   "description": "A package for facilitating rendering FAST Web Components in a non-browser environment.",
   "exports": {
@@ -64,20 +54,15 @@
     "./dist/esm/index.js"
   ],
   "peerDependencies": {
-    "@microsoft/fast-element": "^2.8.0"
+    "@microsoft/fast-element": "^2.8.2"
   },
   "devDependencies": {
     "@ast-grep/cli": "^0.37.0",
     "@microsoft/api-extractor": "^7.47.0",
-    "@microsoft/fast-element": "^2.8.0",
-    "@playwright/test": "^1.49.0",
+    "@microsoft/fast-element": "^2.8.2",
     "@types/express": "^4.17.21",
     "@types/node": "^17.0.17",
-    "express": "^4.19.2",
-    "typescript": "~5.3.0",
-    "webpack": "^5.97.1",
-    "webpack-cli": "^6.0.1",
-    "webpack-merge": "^6.0.1"
+    "typescript": "~5.3.0"
   },
   "beachball": {
     "disallowedChangeTypes": [

package/dist/dts/components/request-idle-callback.d.ts

@@ -1,41 +0,0 @@
-/**
- * A ponyfill for requestIdleCallback that falls back to setTimeout.
- * Uses the native requestIdleCallback when available.
- *
- * @param callback - The function to call when the browser is idle.
- * @param options - Options object that may contain a timeout property.
- * @returns An ID that can be used to cancel the callback.
- * @public
- */
-export declare function requestIdleCallback(callback: (deadline: IdleDeadline) => void, options?: {
-    timeout: number;
-}): ReturnType<typeof globalThis.requestIdleCallback | typeof setTimeout>;
-/**
- * A ponyfill for cancelIdleCallback that falls back to clearTimeout.
- * Uses the native cancelIdleCallback when available.
- *
- * @param id - The ID of the callback to cancel.
- * @public
- */
-export declare function cancelIdleCallback(id: ReturnType<typeof globalThis.requestIdleCallback | typeof setTimeout>): void;
-/**
- * Waits for all custom element descendants of a target element to be connected.
- *
- * @param target - The target element to observe.
- * @param callback - The function to call when all custom element descendants are connected.
- * @param options - Options object that may contain a timeout property for the idle callback.
- *
- * @remarks
- * This function uses requestIdleCallback to periodically check if all custom element
- * descendants (elements with a hyphen in their tag name) are connected to the DOM.
- * Once all such elements are connected, the provided callback is invoked.
- *
- * The `timeout` option specifies the maximum time to wait for each idle callback before
- * rechecking, defaulting to 50 milliseconds.
- *
- * @public
- */
-export declare function waitForConnectedDescendants(target: HTMLElement, callback: () => void, options?: {
-    shallow?: boolean;
-    timeout?: number;
-}): void;

package/dist/dts/fixtures/attribute/attribute.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/attribute/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/binding/binding.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/binding/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/children/children.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/children/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/dot-syntax/dot-syntax.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/dot-syntax/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/event/event.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/event/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/lifecycle-callbacks/lifecycle-callbacks.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/lifecycle-callbacks/main.d.ts

@@ -1,5 +0,0 @@
-export declare const lifecycleEvents: Array<{
-    callback: string;
-    name?: string;
-}>;
-export declare let hydrationCompleteEmitted: boolean;

package/dist/dts/fixtures/observer-map/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/observer-map/observer-map.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/ref/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/ref/ref.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/repeat/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/repeat/repeat.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/slotted/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/slotted/slotted.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/when/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dts/fixtures/when/when.spec.d.ts

@@ -1 +0,0 @@
-export {};