nuxt-ignis 0.4.0 → 0.5.0-rc.1

package/.output/server/node_modules/@iconify/utils/lib/emoji/test/parse.mjs

@@ -0,0 +1,97 @@
+import { getEmojiSequenceFromString, getUnqualifiedEmojiSequence } from '../cleanup.mjs';
+import { getEmojiSequenceKeyword } from '../format.mjs';
+import '../convert.mjs';
+import '../data.mjs';
+
+const componentStatus = "component";
+const allowedStatus = /* @__PURE__ */ new Set([
+  componentStatus,
+  "fully-qualified",
+  "minimally-qualified",
+  "unqualified"
+]);
+function getQualifiedTestData(data) {
+  const results = /* @__PURE__ */ Object.create(null);
+  for (const key in data) {
+    const item = data[key];
+    const sequence = getUnqualifiedEmojiSequence(item.sequence);
+    const shortKey = getEmojiSequenceKeyword(sequence);
+    if (!results[shortKey] || results[shortKey].sequence.length < sequence.length) {
+      results[shortKey] = item;
+    }
+  }
+  return results;
+}
+function parseEmojiTestFile(data) {
+  const results = /* @__PURE__ */ Object.create(null);
+  let group;
+  let subgroup;
+  data.split("\n").forEach((line) => {
+    line = line.trim();
+    const parts = line.split("#");
+    if (parts.length < 2) {
+      return;
+    }
+    const firstChunk = parts.shift().trim();
+    const secondChunk = parts.join("#").trim();
+    if (!firstChunk) {
+      const commentParts = secondChunk.split(":");
+      if (commentParts.length === 2) {
+        const key2 = commentParts[0].trim();
+        const value = commentParts[1].trim();
+        switch (key2) {
+          case "group":
+            group = value;
+            subgroup = void 0;
+            break;
+          case "subgroup":
+            subgroup = value;
+            break;
+        }
+      }
+      return;
+    }
+    if (!group || !subgroup) {
+      return;
+    }
+    const firstChunkParts = firstChunk.split(";");
+    if (firstChunkParts.length !== 2) {
+      return;
+    }
+    const code = firstChunkParts[0].trim();
+    if (!code || !code.match(/^[A-F0-9]+[A-F0-9\s]*[A-F0-9]+$/)) {
+      return;
+    }
+    const status = firstChunkParts[1].trim();
+    if (!allowedStatus.has(status)) {
+      throw new Error(`Bad emoji type: ${status}`);
+    }
+    const secondChunkParts = secondChunk.split(/\s+/);
+    if (secondChunkParts.length < 3) {
+      throw new Error(`Bad emoji comment for: ${code}`);
+    }
+    const emoji = secondChunkParts.shift();
+    const version = secondChunkParts.shift();
+    if (version.slice(0, 1) !== "E") {
+      throw new Error(`Bad unicode version "${version}" for: ${code}`);
+    }
+    const name = secondChunkParts.join(" ");
+    const sequence = getEmojiSequenceFromString(code);
+    const key = getEmojiSequenceKeyword(sequence);
+    if (results[key]) {
+      throw new Error(`Duplicate entry for "${code}"`);
+    }
+    results[key] = {
+      group,
+      subgroup,
+      sequence,
+      emoji,
+      status,
+      version,
+      name
+    };
+  });
+  return getQualifiedTestData(results);
+}
+
+export { componentStatus, parseEmojiTestFile };

package/.output/server/node_modules/@iconify/utils/lib/emoji/test/similar.mjs

@@ -0,0 +1,45 @@
+import { vs16Emoji } from '../data.mjs';
+import { emojiSequenceWithComponentsToString, mapEmojiTestDataComponents } from './components.mjs';
+import { splitEmojiNameVariations } from './name.mjs';
+import '../format.mjs';
+import '../convert.mjs';
+
+function findComponentsInEmojiTestItem(item, componentsData) {
+  const name = splitEmojiNameVariations(
+    item.name,
+    item.sequence,
+    componentsData
+  );
+  const sequence = [...item.sequence];
+  name.variations?.forEach((item2) => {
+    if (typeof item2 !== "string") {
+      sequence[item2.index] = item2.type;
+    }
+  });
+  const sequenceKey = emojiSequenceWithComponentsToString(
+    sequence.filter((code) => code !== vs16Emoji)
+  );
+  return {
+    ...item,
+    name,
+    sequenceKey,
+    sequence
+  };
+}
+function combineSimilarEmojiTestData(data, componentsData) {
+  const results = /* @__PURE__ */ Object.create(null);
+  componentsData = componentsData || mapEmojiTestDataComponents(data);
+  for (const key in data) {
+    const sourceItem = data[key];
+    if (sourceItem.status !== "component") {
+      const item = findComponentsInEmojiTestItem(
+        sourceItem,
+        componentsData
+      );
+      results[item.sequenceKey] = item;
+    }
+  }
+  return results;
+}
+
+export { combineSimilarEmojiTestData, findComponentsInEmojiTestItem };

package/.output/server/node_modules/@iconify/utils/lib/emoji/test/tree.mjs

@@ -0,0 +1,105 @@
+import { emojiComponents } from '../data.mjs';
+
+function mergeComponentTypes(value) {
+  return "[" + value.join(",") + "]";
+}
+function mergeComponentsCount(value) {
+  const keys = [];
+  for (const key in emojiComponents) {
+    const type = key;
+    for (let i = 0; i < value[type]; i++) {
+      keys.push(type);
+    }
+  }
+  return keys.length ? mergeComponentTypes(keys) : "";
+}
+function getGroupItem(items, components) {
+  const key = mergeComponentsCount(components);
+  const item = items[key];
+  if (item) {
+    item.parsed = true;
+    return item.item;
+  }
+}
+function getEmojiTestDataTree(data) {
+  const groups = /* @__PURE__ */ Object.create(null);
+  for (const key in data) {
+    const item = data[key];
+    const text = item.name.key;
+    const parent = groups[text] || (groups[text] = {});
+    const components = {
+      "hair-style": 0,
+      "skin-tone": 0
+    };
+    item.sequence.forEach((value) => {
+      if (typeof value !== "number") {
+        components[value]++;
+      }
+    });
+    const componentsKey = mergeComponentsCount(components);
+    if (parent[componentsKey]) {
+      throw new Error(`Duplicate components tree item for "${text}"`);
+    }
+    parent[componentsKey] = {
+      item: {
+        ...item,
+        components,
+        componentsKey
+      }
+    };
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  for (const key in groups) {
+    const items = groups[key];
+    const check = (parent, parentComponents, type) => {
+      const item = parse(parentComponents, [type]);
+      if (item) {
+        const children = parent.children || (parent.children = {});
+        children[type] = item;
+        return true;
+      }
+    };
+    const parse = (parentComponents, newComponents) => {
+      const components = {
+        "hair-style": 0,
+        "skin-tone": 0
+      };
+      const componentsList = parentComponents.concat(newComponents);
+      componentsList.forEach((type) => {
+        components[type]++;
+      });
+      let item = getGroupItem(items, components);
+      if (!item && newComponents.length === 1 && newComponents[0] === "skin-tone") {
+        const doubleComponents = {
+          ...components
+        };
+        doubleComponents["skin-tone"]++;
+        item = getGroupItem(items, doubleComponents);
+      }
+      if (item) {
+        const result = {
+          item
+        };
+        for (const key2 in emojiComponents) {
+          check(result, componentsList, key2);
+        }
+        return result;
+      }
+    };
+    const root = parse([], []);
+    if (!root) {
+      throw new Error(`Cannot find parent item for "${key}"`);
+    }
+    for (const itemsKey in items) {
+      if (!items[itemsKey].parsed) {
+        throw new Error(`Error generating tree for "${key}"`);
+      }
+    }
+    if (root.children) {
+      results[key] = root;
+    }
+  }
+  return results;
+}
+
+export { getEmojiTestDataTree };

package/.output/server/node_modules/@iconify/utils/lib/emoji/test/variations.mjs

@@ -0,0 +1,54 @@
+import { splitEmojiSequences, joinEmojiSequences, getUnqualifiedEmojiSequence } from '../cleanup.mjs';
+import { convertEmojiSequenceToUTF32 } from '../convert.mjs';
+import { vs16Emoji, keycapEmoji, emojiComponents } from '../data.mjs';
+import { getEmojiSequenceKeyword } from '../format.mjs';
+
+function guessQualifiedEmojiSequence(sequence) {
+  const split = splitEmojiSequences(sequence).map((part) => {
+    if (part.indexOf(vs16Emoji) !== -1) {
+      return part;
+    }
+    if (part.length === 2) {
+      const lastNum = part[1];
+      if (lastNum === keycapEmoji) {
+        return [part[0], vs16Emoji, lastNum];
+      }
+      for (const key in emojiComponents) {
+        const range = emojiComponents[key];
+        if (lastNum >= range[0] && lastNum < range[1]) {
+          return [part[0], vs16Emoji, lastNum];
+        }
+      }
+    }
+    return part.length === 1 ? [part[0], vs16Emoji] : part;
+  });
+  return joinEmojiSequences(split);
+}
+function getQualifiedEmojiVariation(item) {
+  const unqualifiedSequence = getUnqualifiedEmojiSequence(
+    convertEmojiSequenceToUTF32(item.sequence)
+  );
+  const result = {
+    ...item,
+    sequence: guessQualifiedEmojiSequence(unqualifiedSequence)
+  };
+  if (result.sequenceKey) {
+    result.sequenceKey = getEmojiSequenceKeyword(unqualifiedSequence);
+  }
+  return result;
+}
+function getQualifiedEmojiVariations(items) {
+  const results = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < items.length; i++) {
+    const result = getQualifiedEmojiVariation(items[i]);
+    const key = getEmojiSequenceKeyword(
+      getUnqualifiedEmojiSequence(result.sequence)
+    );
+    if (!results[key] || results[key].sequence.length < result.sequence.length) {
+      results[key] = result;
+    }
+  }
+  return Object.values(results);
+}
+
+export { getQualifiedEmojiVariation, getQualifiedEmojiVariations, guessQualifiedEmojiSequence };

package/.output/server/node_modules/@iconify/utils/lib/icon/defaults.mjs

@@ -0,0 +1,24 @@
+const defaultIconDimensions = Object.freeze(
+  {
+    left: 0,
+    top: 0,
+    width: 16,
+    height: 16
+  }
+);
+const defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+const defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+const defaultExtendedIconProps = Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+
+export { defaultExtendedIconProps, defaultIconDimensions, defaultIconProps, defaultIconTransformations };

package/.output/server/node_modules/@iconify/utils/lib/icon/merge.mjs

@@ -0,0 +1,20 @@
+import { defaultExtendedIconProps, defaultIconTransformations } from './defaults.mjs';
+import { mergeIconTransformations } from './transformations.mjs';
+
+function mergeIconData(parent, child) {
+  const result = mergeIconTransformations(parent, child);
+  for (const key in defaultExtendedIconProps) {
+    if (key in defaultIconTransformations) {
+      if (key in parent && !(key in result)) {
+        result[key] = defaultIconTransformations[key];
+      }
+    } else if (key in child) {
+      result[key] = child[key];
+    } else if (key in parent) {
+      result[key] = parent[key];
+    }
+  }
+  return result;
+}
+
+export { mergeIconData };

package/.output/server/node_modules/@iconify/utils/lib/icon/name.mjs

@@ -0,0 +1,53 @@
+const matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const stringToIcon = (value, validate, allowSimpleName, provider = "") => {
+  const colonSeparated = value.split(":");
+  if (value.slice(0, 1) === "@") {
+    if (colonSeparated.length < 2 || colonSeparated.length > 3) {
+      return null;
+    }
+    provider = colonSeparated.shift().slice(1);
+  }
+  if (colonSeparated.length > 3 || !colonSeparated.length) {
+    return null;
+  }
+  if (colonSeparated.length > 1) {
+    const name2 = colonSeparated.pop();
+    const prefix = colonSeparated.pop();
+    const result = {
+      // Allow provider without '@': "provider:prefix:name"
+      provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+      prefix,
+      name: name2
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  const name = colonSeparated[0];
+  const dashSeparated = name.split("-");
+  if (dashSeparated.length > 1) {
+    const result = {
+      provider,
+      prefix: dashSeparated.shift(),
+      name: dashSeparated.join("-")
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  if (allowSimpleName && provider === "") {
+    const result = {
+      provider,
+      prefix: "",
+      name
+    };
+    return validate && !validateIconName(result, allowSimpleName) ? null : result;
+  }
+  return null;
+};
+const validateIconName = (icon, allowSimpleName) => {
+  if (!icon) {
+    return false;
+  }
+  return !!// Check prefix: cannot be empty, unless allowSimpleName is enabled
+  // Check name: cannot be empty
+  ((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
+};
+
+export { matchIconName, stringToIcon, validateIconName };

package/.output/server/node_modules/@iconify/utils/lib/icon/square.mjs

@@ -0,0 +1,23 @@
+function makeIconSquare(icon) {
+  if (icon.width !== icon.height) {
+    const max = Math.max(icon.width, icon.height);
+    return {
+      ...icon,
+      width: max,
+      height: max,
+      left: icon.left - (max - icon.width) / 2,
+      top: icon.top - (max - icon.height) / 2
+    };
+  }
+  return icon;
+}
+function makeViewBoxSquare(viewBox) {
+  const [left, top, width, height] = viewBox;
+  if (width !== height) {
+    const max = Math.max(width, height);
+    return [left - (max - width) / 2, top - (max - height) / 2, max, max];
+  }
+  return viewBox;
+}
+
+export { makeIconSquare, makeViewBoxSquare };

package/.output/server/node_modules/@iconify/utils/lib/icon/transformations.mjs

@@ -0,0 +1,16 @@
+function mergeIconTransformations(obj1, obj2) {
+  const result = {};
+  if (!obj1.hFlip !== !obj2.hFlip) {
+    result.hFlip = true;
+  }
+  if (!obj1.vFlip !== !obj2.vFlip) {
+    result.vFlip = true;
+  }
+  const rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+  if (rotate) {
+    result.rotate = rotate;
+  }
+  return result;
+}
+
+export { mergeIconTransformations };

package/.output/server/node_modules/@iconify/utils/lib/icon-set/convert-info.mjs

@@ -0,0 +1,182 @@
+const minDisplayHeight = 16;
+const maxDisplayHeight = 24;
+function validateDisplayHeight(value) {
+  while (value < minDisplayHeight) {
+    value *= 2;
+  }
+  while (value > maxDisplayHeight) {
+    value /= 2;
+  }
+  return value === Math.round(value) && value >= minDisplayHeight && value <= maxDisplayHeight ? value : 0;
+}
+function convertIconSetInfo(data, expectedPrefix = "") {
+  if (typeof data !== "object" || data === null) {
+    return null;
+  }
+  const source = data;
+  const getSourceNestedString = (field, key, defaultValue = "") => {
+    if (typeof source[field] !== "object") {
+      return defaultValue;
+    }
+    const obj = source[field];
+    return typeof obj[key] === "string" ? obj[key] : defaultValue;
+  };
+  let name;
+  if (typeof source.name === "string") {
+    name = source.name;
+  } else if (typeof source.title === "string") {
+    name = source.title;
+  } else {
+    return null;
+  }
+  if (expectedPrefix !== "" && typeof source.prefix === "string" && source.prefix !== expectedPrefix) {
+    return null;
+  }
+  const info = {
+    name
+  };
+  switch (typeof source.total) {
+    case "number":
+      info.total = source.total;
+      break;
+    case "string": {
+      const num = parseInt(source.total);
+      if (num > 0) {
+        info.total = num;
+      }
+      break;
+    }
+  }
+  if (typeof source.version === "string") {
+    info.version = source.version;
+  }
+  info.author = {
+    name: getSourceNestedString(
+      "author",
+      "name",
+      typeof source.author === "string" ? source.author : ""
+    )
+  };
+  if (typeof source.author === "object") {
+    const sourceAuthor = source.author;
+    if (typeof sourceAuthor.url === "string") {
+      info.author.url = sourceAuthor.url;
+    }
+  }
+  info.license = {
+    title: getSourceNestedString(
+      "license",
+      "title",
+      typeof source.license === "string" ? source.license : ""
+    )
+  };
+  if (typeof source.license === "object") {
+    const sourceLicense = source.license;
+    if (typeof sourceLicense.spdx === "string") {
+      info.license.spdx = sourceLicense.spdx;
+    }
+    if (typeof sourceLicense.url === "string") {
+      info.license.url = sourceLicense.url;
+    }
+  }
+  if (source.samples instanceof Array) {
+    const samples = [];
+    source.samples.forEach((item) => {
+      if (typeof item === "string" && !samples.includes(item)) {
+        samples.push(item);
+      }
+    });
+    if (samples.length) {
+      info.samples = samples;
+    }
+  }
+  if (typeof source.height === "number" || typeof source.height === "string") {
+    const num = parseInt(source.height);
+    if (num > 0) {
+      info.height = num;
+    }
+  }
+  if (source.height instanceof Array) {
+    source.height.forEach((item) => {
+      const num = parseInt(item);
+      if (num > 0) {
+        if (!(info.height instanceof Array)) {
+          info.height = [];
+        }
+        info.height.push(num);
+      }
+    });
+    switch (info.height.length) {
+      case 0:
+        delete info.height;
+        break;
+      case 1:
+        info.height = info.height[0];
+    }
+  }
+  if (typeof info.height === "number") {
+    const displayHeight = validateDisplayHeight(info.height);
+    if (displayHeight && displayHeight !== info.height) {
+      info.displayHeight = displayHeight;
+    }
+  }
+  ["samplesHeight", "displayHeight"].forEach((prop) => {
+    const value = source[prop];
+    if (typeof value === "number" || typeof value === "string") {
+      const displayHeight = validateDisplayHeight(
+        parseInt(value)
+      );
+      if (displayHeight) {
+        info.displayHeight = displayHeight;
+      }
+    }
+  });
+  if (typeof source.category === "string") {
+    info.category = source.category;
+  }
+  if (source.tags instanceof Array) {
+    info.tags = source.tags;
+  }
+  switch (typeof source.palette) {
+    case "boolean":
+      info.palette = source.palette;
+      break;
+    case "string":
+      switch (source.palette.toLowerCase()) {
+        case "colorless":
+        case "false":
+          info.palette = false;
+          break;
+        case "colorful":
+        case "true":
+          info.palette = true;
+      }
+      break;
+  }
+  if (source.hidden === true) {
+    info.hidden = true;
+  }
+  Object.keys(source).forEach((key) => {
+    const value = source[key];
+    if (typeof value !== "string") {
+      return;
+    }
+    switch (key) {
+      case "url":
+      case "uri":
+        info.author.url = value;
+        break;
+      case "licenseURL":
+      case "licenseURI":
+        info.license.url = value;
+        break;
+      case "licenseID":
+      case "licenseSPDX":
+        info.license.spdx = value;
+        break;
+    }
+  });
+  return info;
+}
+
+export { convertIconSetInfo };

package/.output/server/node_modules/@iconify/utils/lib/icon-set/expand.mjs

@@ -0,0 +1,22 @@
+import { defaultIconDimensions } from '../icon/defaults.mjs';
+
+function expandIconSet(data) {
+  const icons = Object.keys(data.icons);
+  Object.keys(
+    defaultIconDimensions
+  ).forEach((prop) => {
+    if (typeof data[prop] !== typeof defaultIconDimensions[prop]) {
+      return;
+    }
+    const value = data[prop];
+    icons.forEach((name) => {
+      const item = data.icons[name];
+      if (!(prop in item)) {
+        item[prop] = value;
+      }
+    });
+    delete data[prop];
+  });
+}
+
+export { expandIconSet };

package/.output/server/node_modules/@iconify/utils/lib/icon-set/get-icon.mjs

@@ -0,0 +1,28 @@
+import { mergeIconData } from '../icon/merge.mjs';
+import { getIconsTree } from './tree.mjs';
+import '../icon/defaults.mjs';
+import '../icon/transformations.mjs';
+
+function internalGetIconData(data, name, tree) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  let currentProps = {};
+  function parse(name2) {
+    currentProps = mergeIconData(
+      icons[name2] || aliases[name2],
+      currentProps
+    );
+  }
+  parse(name);
+  tree.forEach(parse);
+  return mergeIconData(data, currentProps);
+}
+function getIconData(data, name) {
+  if (data.icons[name]) {
+    return internalGetIconData(data, name, []);
+  }
+  const tree = getIconsTree(data, [name])[name];
+  return tree ? internalGetIconData(data, name, tree) : null;
+}
+
+export { getIconData, internalGetIconData };