@digdir/designsystemet 0.1.0-alpha.9 → 0.1.0-next.21

package/dist/src/tokens/configs.js

@@ -0,0 +1,223 @@
+import * as tokenStudio from "@tokens-studio/sd-transforms";
+import * as R from "ramda";
+import StyleDictionary from "style-dictionary";
+import { outputReferencesFilter } from "style-dictionary/utils";
+import { makeEntryFile } from "./actions.js";
+import * as formats from "./formats/css.js";
+import { jsTokens } from "./formats/js-tokens.js";
+import { nameKebab, sizeRem, typographyShorthand } from "./transformers.js";
+import { permutateThemes as permutateThemes_ } from "./utils/permutateThemes.js";
+import { typeEquals } from "./utils/utils.js";
+void tokenStudio.registerTransforms(StyleDictionary);
+const prefix = "ds";
+const basePxFontSize = 16;
+const separator = "_";
+const fileHeader = () => [`These files are generated from design tokens defind using Token Studio`];
+StyleDictionary.registerTransform(sizeRem);
+StyleDictionary.registerTransform(nameKebab);
+StyleDictionary.registerTransform(typographyShorthand);
+StyleDictionary.registerFormat(jsTokens);
+StyleDictionary.registerFormat(formats.colormode);
+StyleDictionary.registerFormat(formats.semantic);
+StyleDictionary.registerFormat(formats.typography);
+StyleDictionary.registerAction(makeEntryFile);
+const dsTransformers = [
+  nameKebab.name,
+  `ts/resolveMath`,
+  "ts/size/px",
+  sizeRem.name,
+  "ts/typography/fontWeight",
+  typographyShorthand.name,
+  "ts/color/modifiers",
+  "ts/color/css/hexrgba",
+  "ts/size/lineheight",
+  "ts/shadow/css/shorthand"
+];
+const paritionPrimitives = R.partition(R.test(/(?!.*global\.json).*primitives.*/));
+const hasUnknownProps = R.pipe(R.values, R.none(R.equals("unknown")), R.not);
+const outputColorReferences = (token) => {
+  if (R.test(/accent|neutral|brand1|brand2|brand3|success|danger|warning/, token.name) && R.includes("semantic/color", token.filePath)) {
+    return true;
+  }
+  return false;
+};
+const permutateThemes = ($themes) => permutateThemes_($themes, {
+  separator
+});
+const colorModeVariables = ({ mode = "light", outPath, theme }) => {
+  const selector = `${mode === "light" ? ":root, " : ""}[data-ds-color-mode="${mode}"]`;
+  const layer = `ds.theme.color-mode.${mode}`;
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        // custom
+        outPath,
+        mode,
+        theme,
+        selector,
+        layer,
+        //
+        prefix,
+        buildPath: `${outPath}/${theme}/`,
+        transforms: dsTransformers,
+        actions: [makeEntryFile.name],
+        files: [
+          {
+            destination: `color-mode/${mode}.css`,
+            format: formats.colormode.name,
+            filter: (token) => !token.isSource && typeEquals("color", token)
+          }
+        ],
+        options: {
+          fileHeader,
+          outputReferences: (token, options) => outputColorReferences(token) && outputReferencesFilter(token, options)
+        }
+      }
+    }
+  };
+};
+const semanticVariables = ({ outPath, theme }) => {
+  const selector = `:root`;
+  const layer = `ds.theme.semantic`;
+  const isCalculatedToken = (token) => typeEquals(["spacing", "sizing", "borderRadius"], token);
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        // custom
+        outPath,
+        theme,
+        basePxFontSize,
+        isCalculatedToken,
+        selector,
+        layer,
+        //
+        prefix,
+        buildPath: `${outPath}/${theme}/`,
+        transforms: dsTransformers,
+        actions: [makeEntryFile.name],
+        files: [
+          {
+            destination: `semantic.css`,
+            format: formats.semantic.name,
+            filter: (token) => (!token.isSource || isCalculatedToken(token)) && !typeEquals(["color", "fontWeights", "fontFamilies"], token)
+          }
+        ],
+        options: {
+          fileHeader,
+          outputReferences: (token, options) => isCalculatedToken(token) && outputReferencesFilter(token, options)
+        }
+      }
+    }
+  };
+};
+const typescriptTokens = ({ mode = "unknown", outPath, theme }) => {
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      ts: {
+        prefix,
+        basePxFontSize,
+        transforms: dsTransformers,
+        buildPath: `${outPath}/${theme}/`,
+        files: [
+          {
+            destination: `${mode}.ts`,
+            format: jsTokens.name,
+            outputReferences: outputColorReferences,
+            filter: (token) => {
+              if (R.test(/primitives\/modes|\/themes/, token.filePath)) {
+                return false;
+              }
+              if (R.test(/accent|neutral|brand1|brand2|brand3|success|danger|warning/, token.name) || R.includes("semantic", token.filePath)) {
+                return true;
+              }
+              return false;
+            }
+          }
+        ],
+        options: {
+          fileHeader
+        }
+      }
+    }
+  };
+};
+const typographyCSS = ({ outPath, theme, typography }) => {
+  const selector = `${typography === "primary" ? ":root, " : ""}[data-ds-typography="${typography}"]`;
+  const layer = `ds.theme.typography.${typography}`;
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        prefix,
+        typography,
+        selector,
+        layer,
+        buildPath: `${outPath}/${theme}/`,
+        basePxFontSize,
+        transforms: [nameKebab.name, "ts/size/px", sizeRem.name, "ts/size/lineheight", "ts/typography/fontWeight"],
+        files: [
+          {
+            destination: `typography/${typography}.css`,
+            format: formats.typography.name,
+            filter: (token) => {
+              return typeEquals(
+                ["typography", "fontweights", "fontfamilies", "lineheights", "fontsizes", "letterSpacing"],
+                token
+              ) && !(token.path[0] || "").startsWith("theme");
+            }
+          }
+        ],
+        options: {
+          fileHeader
+        }
+      }
+    }
+  };
+};
+const getConfigs = (getConfig, outPath, tokensDir, permutatedThemes) => permutatedThemes.map((permutatedTheme) => {
+  const {
+    selectedTokenSets = [],
+    mode = "unknown",
+    theme = "unknown",
+    semantic = "unknown",
+    size = "unknown",
+    typography = "unknown"
+  } = permutatedTheme;
+  if (hasUnknownProps(permutatedTheme)) {
+    throw Error(`Theme ${permutatedTheme.name} has unknown props: ${JSON.stringify(permutatedTheme)}`);
+  }
+  const setsWithPaths = selectedTokenSets.map((x) => `${tokensDir}/${x}.json`);
+  const [source, include] = paritionPrimitives(setsWithPaths);
+  const config_ = getConfig({
+    outPath,
+    theme,
+    mode,
+    semantic,
+    size,
+    typography
+  });
+  const config = {
+    ...config_,
+    source,
+    include
+  };
+  return { mode, theme, semantic, size, typography, config };
+}).sort();
+export {
+  basePxFontSize,
+  colorModeVariables,
+  getConfigs,
+  permutateThemes,
+  prefix,
+  semanticVariables,
+  separator,
+  typescriptTokens,
+  typographyCSS
+};

package/dist/src/tokens/formats/css.js

@@ -0,0 +1,170 @@
+import * as R from "ramda";
+import { createPropertyFormatter, fileHeader, getReferences, usesReferences } from "style-dictionary/utils";
+import { prefix } from "../configs.js";
+import { getValue, typeEquals } from "../utils/utils.js";
+const prefersColorScheme = (mode, content) => `
+@media (prefers-color-scheme: ${mode}) {
+  [data-ds-color-mode="auto"] ${content}
+}
+`;
+const colormode = {
+  name: "ds/css-colormode",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { allTokens } = dictionary;
+    const { outputReferences } = options;
+    const { selector, mode, layer } = platform;
+    const mode_ = mode;
+    const header = await fileHeader({ file });
+    const format = createPropertyFormatter({
+      outputReferences,
+      dictionary,
+      format: "css"
+    });
+    const colorSchemeProperty = mode_ === "dark" || mode_ === "light" ? `color-scheme: ${mode_};
+` : "";
+    const content = `{
+${allTokens.map(format).join("\n")}
+${colorSchemeProperty}}
+`;
+    const autoSelectorContent = ["light", "dark"].includes(mode_) ? prefersColorScheme(mode_, content) : "";
+    return header + `@layer ${layer} {
+${selector} ${content} ${autoSelectorContent}
+}
+`;
+  }
+};
+const calculatedVariable = R.pipe(R.split(/:(.*?);/g), (split) => `${split[0]}: calc(${R.trim(split[1])});`);
+const semantic = {
+  name: "ds/css-semantic",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { allTokens } = dictionary;
+    const { outputReferences } = options;
+    const { selector, isCalculatedToken, layer } = platform;
+    const header = await fileHeader({ file });
+    const format = createPropertyFormatter({
+      outputReferences,
+      dictionary,
+      format: "css"
+    });
+    const formatTokens = R.map((token) => {
+      const originalValue = getValue(token.original);
+      if (usesReferences(originalValue) && typeof outputReferences === "function" && outputReferences?.(token, { dictionary })) {
+        if (isCalculatedToken?.(token, options)) {
+          return calculatedVariable(format(token));
+        }
+      }
+      return format(token);
+    });
+    const formattedVariables = formatTokens(allTokens);
+    const content = `{
+${formattedVariables.join("\n")}
+}
+`;
+    return header + `@layer ${layer} {
+${selector} ${content}
+}
+`;
+  }
+};
+const sortByType = R.sortBy((token) => token?.type === "typography");
+const getVariableName = R.pipe(
+  R.split(":"),
+  R.head,
+  R.defaultTo(""),
+  R.trim,
+  (name) => `var(${name})`
+);
+const bemify = R.pipe(
+  (path) => {
+    const filteredPath = path.filter((p) => p !== "typography");
+    const withPrefix = R.concat([prefix], R.remove(0, 0, filteredPath));
+    const [rest, last] = R.splitAt(-1, withPrefix);
+    const className = `${rest.join("-")}--${R.head(last)}`;
+    return className;
+  },
+  R.trim,
+  R.toLower
+);
+const classSelector = R.pipe(R.prop("path"), bemify);
+const sortTypographyLast = R.sortWith([
+  R.ascend((token) => typeEquals("typography")(token) ? 1 : 0)
+]);
+const typography = {
+  name: "ds/css-typography",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { outputReferences } = options;
+    const { selector, layer } = platform;
+    const header = await fileHeader({ file });
+    const format = createPropertyFormatter({
+      outputReferences,
+      dictionary,
+      format: "css"
+    });
+    const sortedTokens = sortTypographyLast(dictionary.allTokens);
+    const formattedTokens = R.pipe(
+      sortByType,
+      R.reduce(
+        (acc, token) => {
+          if (typeEquals("fontweights", token)) {
+            const className = `
+  .${classSelector(token)} {
+    font-weight: ${getValue(token)};
+  }`;
+            return {
+              ...acc,
+              variables: [...acc.variables, format(token)],
+              classes: [...acc.classes, className]
+            };
+          }
+          if (typeEquals("lineheights", token)) {
+            const className = `
+  .${classSelector(token)} {
+    line-height: ${getValue(token)};
+  }`;
+            return {
+              ...acc,
+              variables: [...acc.variables, format(token)],
+              classes: [...acc.classes, className]
+            };
+          }
+          if (typeEquals("typography", token)) {
+            const references = getReferences(getValue(token.original), dictionary.tokens);
+            const fontweight = R.find(typeEquals(["fontweights"]))(references);
+            const lineheight = R.find(typeEquals(["lineheights"]))(references);
+            const fontsize = R.find(typeEquals(["fontsizes"]))(references);
+            const letterSpacing = R.find(typeEquals(["letterSpacing"]))(references);
+            const fontSizeVar = fontsize ? getVariableName(format(fontsize)) : null;
+            const fontWeightVar = fontweight ? getVariableName(format(fontweight)) : null;
+            const lineheightVar = lineheight ? getVariableName(format(lineheight)) : null;
+            const letterSpacingVar = letterSpacing ? getVariableName(format(letterSpacing)) : null;
+            const className = `
+  .${classSelector(token)} {
+    ${fontSizeVar && `font-size: ${fontSizeVar};`}
+    ${lineheightVar && `line-height: ${lineheightVar};`}
+    ${fontWeightVar && `font-weight: ${fontWeightVar};`}
+    ${letterSpacingVar && `letter-spacing: ${letterSpacingVar};`}
+  }`;
+            return { ...acc, classes: [className, ...acc.classes] };
+          }
+          return { ...acc, variables: [...acc.variables, format(token)] };
+        },
+        { variables: [], classes: [] }
+      )
+    )(sortedTokens);
+    const classes = formattedTokens.classes.join("\n");
+    const variables = formattedTokens.variables.join("\n");
+    const content = selector ? `${selector} {
+${variables}
+${classes}
+}` : classes;
+    return header + `@layer ${layer} {
+${content}
+}
+`;
+  }
+};
+export {
+  colormode,
+  semantic,
+  typography
+};

package/dist/src/tokens/formats/js-tokens.js

@@ -0,0 +1,31 @@
+import * as R from "ramda";
+import { createPropertyFormatter, fileHeader } from "style-dictionary/utils";
+import { getType } from "../utils/utils.js";
+const groupByType = R.groupBy((token) => getType(token));
+const removeUnwatedTokens = R.filter(
+  (token) => !["fds-base_spacing", "fds-base_sizing"].includes(token.name)
+);
+const toCssVarName = R.pipe(R.split(":"), R.head, R.trim);
+const jsTokens = {
+  name: "ds/js-tokens",
+  format: async ({ dictionary, file }) => {
+    const format = createPropertyFormatter({
+      dictionary,
+      format: "css"
+    });
+    const formatTokens = R.map((token) => ({
+      ...token,
+      name: toCssVarName(format(token))
+    }));
+    const processTokens = R.pipe(removeUnwatedTokens, formatTokens, groupByType);
+    const tokens = processTokens(dictionary.allTokens);
+    const content = Object.entries(tokens).map(
+      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
+`
+    ).join("\n");
+    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
+  }
+};
+export {
+  jsTokens
+};

package/dist/src/tokens/transformers.js

@@ -0,0 +1,47 @@
+import * as R from "ramda";
+import { noCase } from "./utils/noCase.js";
+import { getValue, typeEquals } from "./utils/utils.js";
+const isPx = R.test(/\b\d+px\b/g);
+const sizeRem = {
+  name: "ds/size/toRem",
+  type: "value",
+  transitive: true,
+  filter: (token) => typeEquals(["sizing", "spacing", "borderRadius", "fontsizes"], token),
+  transform: (token, config) => {
+    const value = getValue(token);
+    if (isPx(value)) {
+      const baseFont = config.basePxFontSize || 16;
+      const size = parseInt(value);
+      if (size === 0) {
+        return "0";
+      }
+      return `${size / baseFont}rem`;
+    }
+    return value;
+  }
+};
+const nameKebab = {
+  name: "name/cti/hierarchical-kebab",
+  type: "name",
+  transform: (token, options) => {
+    return noCase([options?.prefix].concat(token.path).join("-"), {
+      delimiter: "-",
+      stripRegexp: /[^A-Z0-9_]+/gi
+    });
+  }
+};
+const typographyShorthand = {
+  name: "typography/shorthand",
+  type: "value",
+  transitive: true,
+  filter: (token) => token.type === "typography",
+  transform: (token) => {
+    const typography = getValue(token);
+    return `${typography.fontWeight} ${typography.fontSize}/${typography.lineHeight} '${typography.fontFamily}'`;
+  }
+};
+export {
+  nameKebab,
+  sizeRem,
+  typographyShorthand
+};

package/dist/src/tokens/utils/noCase.js

@@ -0,0 +1,24 @@
+const lowerCase = (text = "") => text.toLowerCase();
+const DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+const DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+function noCase(input, options = {}) {
+  const {
+    splitRegexp = DEFAULT_SPLIT_REGEXP,
+    stripRegexp = DEFAULT_STRIP_REGEXP,
+    transform = lowerCase,
+    delimiter = " "
+  } = options;
+  const result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0") start++;
+  while (result.charAt(end - 1) === "\0") end--;
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+function replace(input, re, value) {
+  if (re instanceof RegExp) return input.replace(re, value);
+  return re.reduce((input2, re2) => input2.replace(re2, value), input);
+}
+export {
+  noCase
+};

package/dist/src/tokens/utils/permutateThemes.js

@@ -0,0 +1,64 @@
+import { TokenSetStatus } from "@tokens-studio/types";
+import * as R from "ramda";
+function mapThemesToSetsObject(themes) {
+  return themes.map((theme) => ({ name: theme.name, selectedTokenSets: filterTokenSets(theme.selectedTokenSets) }));
+}
+function permutateThemes(themes, { separator = "-" } = {}) {
+  if (!themes.some((theme) => theme.group)) {
+    return mapThemesToSetsObject(themes);
+  }
+  const groups = {};
+  themes.forEach((theme) => {
+    if (theme.group) {
+      groups[theme.group] = [...groups[theme.group] ?? [], theme];
+    } else {
+      throw new Error(
+        `Theme ${theme.name} does not have a group property, which is required for multi-dimensional theming.`
+      );
+    }
+  });
+  if (Object.keys(groups).length <= 1) {
+    return mapThemesToSetsObject(themes);
+  }
+  const permutations = cartesian(Object.values(groups));
+  const permutatedThemes = permutations.map((perm) => {
+    const permutatedTheme = perm.reduce(
+      (acc, theme) => {
+        const { group, name, selectedTokenSets } = theme;
+        let updatedPermutatedTheme = acc;
+        if (group) {
+          const groupProp = R.lensProp(group.toLowerCase());
+          updatedPermutatedTheme = R.set(groupProp, name.toLowerCase(), updatedPermutatedTheme);
+        }
+        const updatedName = `${String(acc.name)}${acc ? separator : ""}${name}`;
+        const sets = [...updatedPermutatedTheme.selectedTokenSets, ...filterTokenSets(selectedTokenSets)];
+        return {
+          ...updatedPermutatedTheme,
+          name: updatedName,
+          selectedTokenSets: sets
+        };
+      },
+      { name: "", selectedTokenSets: [] }
+    );
+    const uniqueTokenSets = new Set(permutatedTheme.selectedTokenSets);
+    return { ...permutatedTheme, selectedTokenSets: Array.from(uniqueTokenSets) };
+  });
+  return permutatedThemes;
+}
+function filterTokenSets(tokensets) {
+  return Object.entries(tokensets).filter(([, val]) => val !== TokenSetStatus.DISABLED).sort((a, b) => {
+    if (a[1] === TokenSetStatus.SOURCE && b[1] === TokenSetStatus.ENABLED) {
+      return -1;
+    }
+    if (a[1] === TokenSetStatus.ENABLED && b[1] === TokenSetStatus.SOURCE) {
+      return 1;
+    }
+    return 0;
+  }).map((entry) => entry[0]);
+}
+function cartesian(a) {
+  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e].flat())));
+}
+export {
+  permutateThemes
+};

package/dist/src/tokens/utils/utils.js

@@ -0,0 +1,14 @@
+import * as R from "ramda";
+const getType = (token) => (token.$type ?? token.type) || "";
+const getValue = (token) => token.$value ?? token.value;
+const typeEquals = R.curry((types, token) => {
+  if (R.isNil(token)) {
+    return false;
+  }
+  return R.includes(R.toLower(getType(token)), R.map(R.toLower, Array.isArray(types) ? types : [types]));
+});
+export {
+  getType,
+  getValue,
+  typeEquals
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digdir/designsystemet",
-  "version": "0.1.0-alpha.9",
+  "version": "0.1.0-next.21",
   "description": "CLI for Designsystemet",
   "author": "Designsystemet team",
   "repository": {
@@ -10,8 +10,13 @@
   "homepage": "https://github.com/digdir/designsystemet/tree/main/scripts/cli",
   "license": "MIT",
   "type": "module",
+  "types": "./dist/types",
+  "files": [
+    "./dist/**"
+  ],
+  "bin": "dist/bin/designsystemet.js",
   "exports": {
-    "./color": "./src/colors/index.ts"
+    "./color": "./dist/src/colors/index.js"
   },
   "publishConfig": {
     "access": "public"
@@ -20,20 +25,19 @@
     "designsystemet": "tsx ./bin/designsystemet.ts",
     "build:tokens": "yarn clean:theme && yarn designsystemet tokens -p -t ../../design-tokens -o ../../packages/theme/brand",
     "build:tokens:debug": "yarn clean:theme && tsx --inspect-brk ./bin/designsystemet.ts tokens -p -t ../../design-tokens -o ../../packages/theme/brand",
-    "build": "yarn clean && tsc",
-    "prepublish:tsup": "yarn clean && tsup src/**/*.ts bin/designsystemet.ts --cjsInterop --shims --format esm",
+    "build": "tsup",
+    "build:swc": "yarn clean && swc src bin --copy-files -d dist && yarn build:types",
+    "build:types": "tsc --emitDeclarationOnly --declaration",
     "clean": "rimraf dist",
     "clean:theme": "yarn workspace @digdir/designsystemet-theme clean"
   },
-  "files": [
-    "./dist/**"
-  ],
-  "bin": "dist/build/bin/designsystemet.js",
   "dependencies": {
     "@adobe/leonardo-contrast-colors": "^1.0.0",
     "@commander-js/extra-typings": "^12.0.1",
     "@tokens-studio/sd-transforms": "^0.16.1",
+    "apca-w3": "^0.1.9",
     "chalk": "^5.3.0",
+    "change-case": "^5.3.0",
     "chroma-js": "^2.4.2",
     "commander": "^12.0.0",
     "fast-glob": "^3.3.2",
@@ -41,21 +45,25 @@
     "jscodeshift": "^0.15.2",
     "object-hash": "^3.0.0",
     "postcss": "^8.4.38",
+    "prompts": "^2.4.0",
     "ramda": "^0.29.1",
     "rimraf": "^5.0.5",
-    "style-dictionary": "^4.0.0-prerelease.34",
-    "tsup": "^8.0.2"
+    "style-dictionary": "^4.0.0-prerelease.34"
   },
   "devDependencies": {
+    "@swc/cli": "^0.3.14",
+    "@swc/core": "^1.6.5",
+    "@types/apca-w3": "^0.1.3",
     "@types/fs-extra": "^11.0.4",
     "@types/glob": "^8.1.0",
     "@types/jscodeshift": "^0.11.11",
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.14.12",
     "@types/object-hash": "^3",
+    "@types/prompts": "^2.4.9",
     "@types/ramda": "^0.29.9",
     "fs-extra": "^11.2.0",
+    "tsup": "^8.1.0",
     "tsx": "^4.11.2",
     "typescript": "^5.4.5"
-  },
-  "gitHead": "87591aa2ce0bbcb4fc451ddcbb2ae9f15cfcfeca"
+  }
 }

package/LICENSE

@@ -1,7 +0,0 @@
-Copyright 2024 Digitaliseringsdirektoratet (Digdir)
-
-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.