devskill 2.0.7 → 2.0.8

package/skills/powerbi-modeling/references/RLS.md

@@ -0,0 +1,226 @@
+# Row-Level Security (RLS) in Power BI
+
+## Overview
+
+Row-Level Security restricts data access at the row level based on user identity. Users see only the data they're authorized to view.
+
+## Design Principles
+
+### 1. Filter on Dimension Tables
+Apply RLS to dimensions, not fact tables:
+- More efficient (smaller tables)
+- Filters propagate through relationships
+- Easier to maintain
+
+```dax
+// On Customer dimension - filters propagate to Sales
+[Region] = "West"
+```
+
+### 2. Create Minimal Roles
+Avoid many role combinations:
+- Each role = separate cache
+- Roles are additive (union, not intersection)
+- Consolidate where possible
+
+### 3. Use Dynamic RLS When Possible
+Data-driven rules scale better:
+- User mapping in a table
+- USERPRINCIPALNAME() for identity
+- No role changes when users change
+
+## Static vs Dynamic RLS
+
+### Static RLS
+Fixed rules per role:
+```dax
+// Role: West Region
+[Region] = "West"
+
+// Role: East Region  
+[Region] = "East"
+```
+
+**Pros:** Simple, clear
+**Cons:** Doesn't scale, requires role per group
+
+### Dynamic RLS
+User identity drives filtering:
+```dax
+// Single role filters based on logged-in user
+[ManagerEmail] = USERPRINCIPALNAME()
+```
+
+**Pros:** Scales, self-maintaining
+**Cons:** Requires user mapping data
+
+## Implementation Patterns
+
+### Pattern 1: Direct User Mapping
+User email in dimension table:
+```dax
+// On Customer table
+[CustomerEmail] = USERPRINCIPALNAME()
+```
+
+### Pattern 2: Security Table
+Separate table mapping users to data:
+```
+SecurityMapping table:
+| UserEmail | Region |
+|-----------|--------|
+| joe@co.com | West  |
+| sue@co.com | East  |
+```
+
+```dax
+// On Region dimension
+[Region] IN 
+    SELECTCOLUMNS(
+        FILTER(SecurityMapping, [UserEmail] = USERPRINCIPALNAME()),
+        "Region", [Region]
+    )
+```
+
+### Pattern 3: Manager Hierarchy
+Users see their data plus subordinates:
+```dax
+// Using PATH functions for hierarchy
+PATHCONTAINS(Employee[ManagerPath], 
+    LOOKUPVALUE(Employee[EmployeeID], Employee[Email], USERPRINCIPALNAME()))
+```
+
+### Pattern 4: Multiple Rules
+Combine conditions:
+```dax
+// Users see their region OR if they're a global viewer
+[Region] = LOOKUPVALUE(Users[Region], Users[Email], USERPRINCIPALNAME())
+|| LOOKUPVALUE(Users[IsGlobal], Users[Email], USERPRINCIPALNAME()) = TRUE()
+```
+
+## Creating Roles via MCP
+
+### List Existing Roles
+```
+security_role_operations(operation: "List")
+```
+
+### Create Role with Permission
+```
+security_role_operations(
+  operation: "Create",
+  definitions: [{
+    name: "Regional Sales",
+    modelPermission: "Read",
+    description: "Restricts sales data by region"
+  }]
+)
+```
+
+### Add Table Permission (Filter)
+```
+security_role_operations(
+  operation: "CreatePermissions",
+  permissionDefinitions: [{
+    roleName: "Regional Sales",
+    tableName: "Customer",
+    filterExpression: "[Region] = USERPRINCIPALNAME()"
+  }]
+)
+```
+
+### Get Effective Permissions
+```
+security_role_operations(
+  operation: "GetEffectivePermissions",
+  references: [{ name: "Regional Sales" }]
+)
+```
+
+## Testing RLS
+
+### In Power BI Desktop
+1. Modeling tab > View As
+2. Select role(s) to test
+3. Optionally specify user identity
+4. Verify data filtering
+
+### Test Unexpected Values
+For dynamic RLS, test:
+- Valid users
+- Unknown users (should see nothing or error gracefully)
+- NULL/blank values
+
+```dax
+// Defensive pattern - returns no data for unknown users
+IF(
+    USERPRINCIPALNAME() IN VALUES(SecurityMapping[UserEmail]),
+    [Region] IN SELECTCOLUMNS(...),
+    FALSE()
+)
+```
+
+## Common Mistakes
+
+### 1. RLS on Fact Tables Only
+**Problem:** Large table scans, poor performance
+**Solution:** Apply to dimension tables, let relationships propagate
+
+### 2. Using LOOKUPVALUE Instead of Relationships
+**Problem:** Expensive, doesn't scale
+**Solution:** Create proper relationships, let filters flow
+
+### 3. Expecting Intersection Behavior
+**Problem:** Multiple roles = UNION (additive), not intersection
+**Solution:** Design roles with union behavior in mind
+
+### 4. Forgetting About DirectQuery
+**Problem:** RLS filters become WHERE clauses
+**Solution:** Ensure source database can handle the query patterns
+
+### 5. Not Testing Edge Cases
+**Problem:** Users see unexpected data
+**Solution:** Test with: valid users, invalid users, multiple roles
+
+## Bidirectional RLS
+
+For bidirectional relationships with RLS:
+```
+Enable "Apply security filter in both directions"
+```
+
+Only use when:
+- RLS requires filtering through many-to-many
+- Dimension-to-dimension security needed
+
+**Caution:** Only one bidirectional relationship per path allowed.
+
+## Performance Considerations
+
+- RLS adds WHERE clauses to every query
+- Complex DAX in filters hurts performance
+- Test with realistic user counts
+- Consider aggregations for large models
+
+## Object-Level Security (OLS)
+
+Restrict access to entire tables or columns:
+```
+// Via XMLA/TMSL - not available in Desktop UI
+```
+
+Use for:
+- Hiding sensitive columns (salary, SSN)
+- Restricting entire tables
+- Combined with RLS for comprehensive security
+
+## Validation Checklist
+
+- [ ] RLS applied to dimension tables (not fact tables)
+- [ ] Filters propagate correctly through relationships
+- [ ] Dynamic RLS uses USERPRINCIPALNAME()
+- [ ] Tested with valid and invalid users
+- [ ] Edge cases handled (NULL, unknown users)
+- [ ] Performance tested under load
+- [ ] Role mappings documented
+- [ ] Workspace roles understood (Admins bypass RLS)

package/skills/powerbi-modeling/references/STAR-SCHEMA.md

@@ -0,0 +1,103 @@
+# Star Schema Design for Power BI
+
+## Overview
+
+Star schema is the optimal design pattern for Power BI semantic models. It organizes data into:
+- **Dimension tables**: Enable filtering and grouping (the "one" side)
+- **Fact tables**: Enable summarization (the "many" side)
+
+## Table Classification
+
+### Dimension Tables
+- Contain descriptive attributes for filtering/slicing
+- Have unique key columns (one row per entity)
+- Examples: Customer, Product, Date, Geography, Employee
+- Naming convention: Singular noun (`Customer`, `Product`)
+
+### Fact Tables  
+- Contain measurable, quantitative data
+- Have foreign keys to dimensions
+- Store data at consistent grain (one row per transaction/event)
+- Examples: Sales, Orders, Inventory, WebVisits
+- Naming convention: Business process noun (`Sales`, `Orders`)
+
+## Design Principles
+
+### 1. Separate Dimensions from Facts
+```
+BAD:  Single denormalized "Sales" table with customer details
+GOOD: "Sales" fact table + "Customer" dimension table
+```
+
+### 2. Consistent Grain
+Every row in a fact table represents the same thing:
+- Order line level (most common)
+- Daily aggregation
+- Monthly summary
+
+Never mix grains in one table.
+
+### 3. Surrogate Keys
+Add surrogate keys when source lacks unique identifiers:
+```m
+// Power Query: Add index column
+= Table.AddIndexColumn(Source, "CustomerKey", 1, 1)
+```
+
+### 4. Date Dimension
+Always create a dedicated date table:
+- Mark as date table in Power BI
+- Include fiscal periods if needed
+- Add relative date columns (IsCurrentMonth, IsPreviousYear)
+
+```dax
+Date = 
+ADDCOLUMNS(
+    CALENDAR(DATE(2020,1,1), DATE(2030,12,31)),
+    "Year", YEAR([Date]),
+    "Month", FORMAT([Date], "MMMM"),
+    "MonthNum", MONTH([Date]),
+    "Quarter", "Q" & FORMAT([Date], "Q"),
+    "WeekDay", FORMAT([Date], "dddd")
+)
+```
+
+## Special Dimension Types
+
+### Role-Playing Dimensions
+Same dimension used multiple times (e.g., Date for OrderDate, ShipDate):
+- Option 1: Duplicate the table (OrderDate, ShipDate tables)
+- Option 2: Use inactive relationships with USERELATIONSHIP in DAX
+
+### Slowly Changing Dimensions (Type 2)
+Track historical changes with version columns:
+- StartDate, EndDate columns
+- IsCurrent flag
+- Requires pre-processing in data warehouse
+
+### Junk Dimensions
+Combine low-cardinality flags into one table:
+```
+OrderFlags dimension: IsRush, IsGift, IsOnline
+```
+
+### Degenerate Dimensions
+Keep transaction identifiers (OrderNumber, InvoiceID) in fact table.
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Problem | Solution |
+|--------------|---------|----------|
+| Wide denormalized tables | Poor performance, hard to maintain | Split into star schema |
+| Snowflake (normalized dims) | Extra joins hurt performance | Flatten dimensions |
+| Many-to-many without bridge | Ambiguous results | Add bridge/junction table |
+| Mixed grain facts | Incorrect aggregations | Separate tables per grain |
+
+## Validation Checklist
+
+- [ ] Each table is clearly dimension or fact
+- [ ] Fact tables have foreign keys to all related dimensions
+- [ ] Dimensions have unique key columns
+- [ ] Date table exists and is marked
+- [ ] No circular relationship paths
+- [ ] Consistent naming conventions

package/skills/prd/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/prd/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: prd
+description: 'Generate high-quality Product Requirements Documents (PRDs) for software systems and AI-powered features. Includes executive summaries, user stories, technical specifications, and risk analysis.'
+license: MIT
+---
+
+# Product Requirements Document (PRD)
+
+## Overview
+
+Design comprehensive, production-grade Product Requirements Documents (PRDs) that bridge the gap between business vision and technical execution. This skill works for modern software systems, ensuring that requirements are clearly defined.
+
+## When to Use
+
+Use this skill when:
+
+- Starting a new product or feature development cycle
+- Translating a vague idea into a concrete technical specification
+- Defining requirements for AI-powered features
+- Stakeholders need a unified "source of truth" for project scope
+- User asks to "write a PRD", "document requirements", or "plan a feature"
+
+---
+
+## Operational Workflow
+
+### Phase 1: Discovery (The Interview)
+
+Before writing a single line of the PRD, you **MUST** interrogate the user to fill knowledge gaps. Do not assume context.
+
+**Ask about:**
+
+- **The Core Problem**: Why are we building this now?
+- **Success Metrics**: How do we know it worked?
+- **Constraints**: Budget, tech stack, or deadline?
+
+### Phase 2: Analysis & Scoping
+
+Synthesize the user's input. Identify dependencies and hidden complexities.
+
+- Map out the **User Flow**.
+- Define **Non-Goals** to protect the timeline.
+
+### Phase 3: Technical Drafting
+
+Generate the document using the **Strict PRD Schema** below.
+
+---
+
+## PRD Quality Standards
+
+### Requirements Quality
+
+Use concrete, measurable criteria. Avoid "fast", "easy", or "intuitive".
+
+```diff
+# Vague (BAD)
+- The search should be fast and return relevant results.
+- The UI must look modern and be easy to use.
+
+# Concrete (GOOD)
++ The search must return results within 200ms for a 10k record dataset.
++ The search algorithm must achieve >= 85% Precision@10 in benchmark evals.
++ The UI must follow the 'Vercel/Next.js' design system and achieve 100% Lighthouse Accessibility score.
+```
+
+---
+
+## Strict PRD Schema
+
+You **MUST** follow this exact structure for the output:
+
+### 1. Executive Summary
+
+- **Problem Statement**: 1-2 sentences on the pain point.
+- **Proposed Solution**: 1-2 sentences on the fix.
+- **Success Criteria**: 3-5 measurable KPIs.
+
+### 2. User Experience & Functionality
+
+- **User Personas**: Who is this for?
+- **User Stories**: `As a [user], I want to [action] so that [benefit].`
+- **Acceptance Criteria**: Bulleted list of "Done" definitions for each story.
+- **Non-Goals**: What are we NOT building?
+
+### 3. AI System Requirements (If Applicable)
+
+- **Tool Requirements**: What tools and APIs are needed?
+- **Evaluation Strategy**: How to measure output quality and accuracy.
+
+### 4. Technical Specifications
+
+- **Architecture Overview**: Data flow and component interaction.
+- **Integration Points**: APIs, DBs, and Auth.
+- **Security & Privacy**: Data handling and compliance.
+
+### 5. Risks & Roadmap
+
+- **Phased Rollout**: MVP -> v1.1 -> v2.0.
+- **Technical Risks**: Latency, cost, or dependency failures.
+
+---
+
+## Implementation Guidelines
+
+### DO (Always)
+
+- **Define Testing**: For AI systems, specify how to test and validate output quality.
+- **Iterate**: Present a draft and ask for feedback on specific sections.
+
+### DON'T (Avoid)
+
+- **Skip Discovery**: Never write a PRD without asking at least 2 clarifying questions first.
+- **Hallucinate Constraints**: If the user didn't specify a tech stack, ask or label it as `TBD`.
+
+---
+
+## Example: Intelligent Search System
+
+### 1. Executive Summary
+
+**Problem**: Users struggle to find specific documentation snippets in massive repositories.
+**Solution**: An intelligent search system that provides direct answers with source citations.
+**Success**:
+
+- Reduce search time by 50%.
+- Citation accuracy >= 95%.
+
+### 2. User Stories
+
+- **Story**: As a developer, I want to ask natural language questions so I don't have to guess keywords.
+- **AC**:
+  - Supports multi-turn clarification.
+  - Returns code blocks with "Copy" button.
+
+### 3. AI System Architecture
+
+- **Tools Required**: `codesearch`, `grep`, `webfetch`.
+
+### 4. Evaluation
+
+- **Benchmark**: Test with 50 common developer questions.
+- **Pass Rate**: 90% must match expected citations.

package/skills/prd/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/prd`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/premium-frontend-ui/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/premium-frontend-ui/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: premium-frontend-ui
+description: 'A comprehensive guide for GitHub Copilot to craft immersive, high-performance web experiences with advanced motion, typography, and architectural craftsmanship.'
+---
+
+# Immersive Frontend UI Craftsmanship
+
+As an AI engineering assistant, your role when building premium frontend experiences goes beyond outputting functional HTML and CSS. You must architect **immersive digital environments**. This skill provides the blueprint for generating highly intentional, award-level web applications that prioritize aesthetic quality, deep interactivity, and flawless performance.
+
+When a user requests a high-end landing page, an interactive portfolio, or a specialized component that requires top-tier visual polish, apply the following rigorous standards to every line of code you generate.
+
+---
+
+## 1. Establishing the Creative Foundation
+
+Before generating layout code, ensure you understand the core emotional resonance the UI should deliver. Do not default to generic, unopinionated code. 
+
+Commit to a strong visual identity in your CSS and component structure:
+- **Editorial Brutalism**: High-contrast monochromatic palettes, oversized typography, sharp rectangular edges, and raw grid structures.
+- **Organic Fluidity**: Soft gradients, deeply rounded corners, glassmorphism overlays, and bouncy spring-based physics.
+- **Cyber / Technical**: Dark mode dominance, glowing neon accents, monospaced typography, and rapid, staggered reveal animations.
+- **Cinematic Pacing**: Full-viewport imagery, slow cross-fades, profound use of negative space, and scroll-dependent storytelling.
+
+---
+
+## 2. Structural Requirements for Immersive UI
+
+When scaffolding a page or generating core components, include the following architectural layers to transform a standard page into an experience.
+
+### 2.1 The Entry Sequence (Preloading & Initialization)
+A blank screen is unacceptable. The user's first interaction must set expectations.
+- **Implementation**: Generate a lightweight preloader component that handles asset resolution (fonts, initial images, 3D models).
+- **Animation**: Output code that transitions the preloader away fluidly—such as a split-door reveal, a scale-up zoom, or a staggered text sweep.
+
+### 2.2 The Hero Architecture
+The top fold must command attention immediately.
+- **Visuals**: Output code that implements full-bleed containers (`100vh`/`100dvh`).
+- **Typography Engine**: Ensure headlines are broken down syntactically (e.g., span wrapping by word or character) to allow for cascading entrance animations.
+- **Depth**: Utilize subtle floating elements or background clipping paths to create a sense of scale and depth behind the primary copy.
+
+### 2.3 Fluid & Contextual Navigation
+- **Implementation**: Do not generate standard static navbars. Output sticky headers that react toscroll direction (hide on scroll down, reveal on scroll up).
+- **Interactivity**: Include hover states that reveal rich content (e.g., mega-menus that display image previews of the hovered link).
+
+---
+
+## 3. The Motion Design System
+
+Animation is not an afterthought; it is the connective tissue of a premium site. Always implement the following motion principles:
+
+### 3.1 Scroll-Driven Narratives
+Generate code utilizing modern scroll libraries (like GSAP's ScrollTrigger) to tie animations to user progress.
+- **Pinned Containers**: Create sections that lock into the viewport while secondary content flows past or reveals itself.
+- **Horizontal Journeys**: Translate vertical scroll data into horizontal movement for specific galleries or showcases.
+- **Parallax Mapping**: Assign subtle, varying scroll-speeds to background elements, midground text, and foreground imagery.
+
+### 3.2 High-Fidelity Micro-Interactions
+The cursor is the user's avatar. Build interactions around it.
+- **Magnetic Components**: Write logic that calculates the distance between the mouse pointer and a button, pulling the button towards the cursor dynamically.
+- **Custom Tracking Elements**: Generate custom cursor components that follow the mouse with calculated interpolation (lerp) for a smooth drag effect.
+- **Dimensional Hover States**: Use CSS Transforms (`scale`, `rotateX`, `translate3d`) to give interactive elements weight and tactile feedback.
+
+---
+
+## 4. Typography & Visual Texture
+
+The aesthetics of your generated code must reflect premium craftsmanship.
+
+- **Type Hierarchy**: Enforce massive contrast in scale. Headlines should utilize extreme sizing (`clamp()` functions spanning up to `12vw`), while body copy remains incredibly crisp (`16px-18px` minimum). 
+- **Font Selection**: Always recommend or implement highly specified variable fonts or premium typefaces over system defaults.
+- **Atmospheric Filters**: Implement CSS/SVG noise overlays (`mix-blend-mode: overlay`, opacity `0.02 - 0.05`) to remove digital sterility and add photographic grain.
+- **Lighting & Glass**: Utilize `backdrop-filter: blur(x)` combined with ultra-thin, semi-transparent borders to create modern, frosted-glass depth.
+
+---
+
+## 5. The Performance Imperative
+
+A beautiful site that stutters is a failure. Enforce strict performance guardrails in all generated code:
+
+- **Hardware Acceleration**: Only animate properties that do not trigger layout recalculations: `transform` and `opacity`. Code that animates `width`, `height`, `top`, or `margin` should be fiercely avoided.
+- **Render Optimization**: Apply `will-change: transform` intelligently on complex moving elements, but remove it post-animation to conserve memory.
+- **Responsive Degradation**: Wrap custom cursor logic and heavy hover animations in `@media (hover: hover) and (pointer: fine)` to ensure pristine performance on touch devices.
+- **Accessibility**: Wrap heavy continuous animations in `@media (prefers-reduced-motion: no-preference)`. Never sacrifice user accessibility for aesthetic flair.
+
+---
+
+## 6. Implementation Ecosystem
+
+When the user asks you to implement these patterns, leverage industry-standard libraries tailored to their framework:
+
+### For React / Next.js Targets
+- Structure the application to support **Framer Motion** for layout transitions and spring physics.
+- Recommend **Lenis** (`@studio-freight/lenis`) for smooth scrolling context.
+- Implement **React Three Fiber** (`@react-three/fiber`) if webGL or 3D interactions are requested.
+
+### For Vanilla / HTML / Astro Targets
+- Rely heavily on **GSAP** (GreenSock Animation Platform) for timeline sequencing.
+- Utilize vanilla **Lenis** via CDN for scroll hijacking and smoothing.
+- Use **SplitType** for safe, accessible typography chunking.
+
+---
+
+## Summary of Action
+
+Whenever you receive a prompt to "Build a premium landing page," "Create an Awwwards-style component," or "Design an immersive UI," you must automatically:
+1. Wrap the output in a robust, scroll-smoothed architecture.
+2. Provide CSS that guarantees perfect performance using composited layers.
+3. Integrate sweeping, staggered component entrances.
+4. Elevate the typography using fluid scales.
+5. Create an intentional, memorable aesthetic footprint.

package/skills/premium-frontend-ui/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/premium-frontend-ui`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/project-workflow-analysis-blueprint-generator/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.