@legionworks/facet 1.9.0

package/dist/gallery/frame/chunks/markdown-y18mve73.js

@@ -0,0 +1,85 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  RailroadPegGrammarGeneratedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-JG7HCLWE.mjs
+var RailroadPegTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "RailroadPegTokenBuilder");
+  }
+  constructor() {
+    super(["railroad-peg-beta"]);
+  }
+};
+var decodeEscapedString = /* @__PURE__ */ __name((input) => {
+  const content = input.slice(1, -1);
+  let value = "";
+  for (let index = 0;index < content.length; index++) {
+    const character = content[index];
+    if (character === "\\" && index + 1 < content.length) {
+      index++;
+      const escaped = content[index];
+      switch (escaped) {
+        case "n":
+          value += `
+`;
+          break;
+        case "r":
+          value += "\r";
+          break;
+        case "t":
+          value += "\t";
+          break;
+        default:
+          value += escaped;
+      }
+      continue;
+    }
+    value += character;
+  }
+  return value;
+}, "decodeEscapedString");
+var RailroadPegValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "RailroadPegValueConverter");
+  }
+  runConverter(rule, input, cstNode) {
+    const value = super.runConverter(rule, input, cstNode);
+    if (rule.name === "TITLE" && typeof value === "string") {
+      const trimmedValue = value.trim();
+      if (trimmedValue.startsWith('"') && trimmedValue.endsWith('"') || trimmedValue.startsWith("'") && trimmedValue.endsWith("'")) {
+        return decodeEscapedString(trimmedValue);
+      }
+    }
+    return value;
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "PEG_STRING") {
+      return decodeEscapedString(input);
+    }
+    return;
+  }
+};
+var RailroadPegModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new RailroadPegTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new RailroadPegValueConverter, "ValueConverter")
+  }
+};
+function createRailroadPegServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const RailroadPeg = inject(createDefaultCoreModule({ shared }), RailroadPegGrammarGeneratedModule, RailroadPegModule);
+  shared.ServiceRegistry.register(RailroadPeg);
+  return { shared, RailroadPeg };
+}
+__name(createRailroadPegServices, "createRailroadPegServices");
+
+export { RailroadPegModule, createRailroadPegServices };

package/dist/gallery/frame/chunks/markdown-yengsms5.js

@@ -0,0 +1,427 @@
+import {
+  getConfig,
+  sanitizeText
+} from "./markdown-92n37gd4.js";
+import {
+  log
+} from "./markdown-xw8dsk8b.js";
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+// node_modules/@iconify/utils/lib/icon/name.js
+var 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 = {
+      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;
+};
+var validateIconName = (icon, allowSimpleName) => {
+  if (!icon)
+    return false;
+  return !!((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
+};
+// node_modules/@iconify/utils/lib/icon/defaults.js
+var defaultIconDimensions = Object.freeze({
+  left: 0,
+  top: 0,
+  width: 16,
+  height: 16
+});
+var defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+var defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+var defaultExtendedIconProps = Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+
+// node_modules/@iconify/utils/lib/icon/transformations.js
+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;
+}
+
+// node_modules/@iconify/utils/lib/icon/merge.js
+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;
+}
+
+// node_modules/@iconify/utils/lib/icon-set/tree.js
+function getIconsTree(data, names) {
+  const icons = data.icons;
+  const aliases = data.aliases || Object.create(null);
+  const resolved = Object.create(null);
+  function resolve(name) {
+    if (icons[name])
+      return resolved[name] = [];
+    if (!(name in resolved)) {
+      resolved[name] = null;
+      const parent = aliases[name] && aliases[name].parent;
+      const value = parent && resolve(parent);
+      if (value)
+        resolved[name] = [parent].concat(value);
+    }
+    return resolved[name];
+  }
+  (names || Object.keys(icons).concat(Object.keys(aliases))).forEach(resolve);
+  return resolved;
+}
+
+// node_modules/@iconify/utils/lib/icon-set/get-icon.js
+function internalGetIconData(data, name, tree) {
+  const icons = data.icons;
+  const aliases = data.aliases || 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;
+}
+// node_modules/@iconify/utils/lib/customisations/defaults.js
+var defaultIconSizeCustomisations = Object.freeze({
+  width: null,
+  height: null
+});
+var defaultIconCustomisations = Object.freeze({
+  ...defaultIconSizeCustomisations,
+  ...defaultIconTransformations
+});
+
+// node_modules/@iconify/utils/lib/svg/size.js
+var unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+var unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+  if (ratio === 1)
+    return size;
+  precision = precision || 100;
+  if (typeof size === "number")
+    return Math.ceil(size * ratio * precision) / precision;
+  if (typeof size !== "string")
+    return size;
+  const oldParts = size.split(unitsSplit);
+  if (oldParts === null || !oldParts.length)
+    return size;
+  const newParts = [];
+  let code = oldParts.shift();
+  let isNumber = unitsTest.test(code);
+  while (true) {
+    if (isNumber) {
+      const num = parseFloat(code);
+      if (isNaN(num))
+        newParts.push(code);
+      else
+        newParts.push(Math.ceil(num * ratio * precision) / precision);
+    } else
+      newParts.push(code);
+    code = oldParts.shift();
+    if (code === undefined)
+      return newParts.join("");
+    isNumber = !isNumber;
+  }
+}
+
+// node_modules/@iconify/utils/lib/svg/defs.js
+function splitSVGDefs(content, tag = "defs") {
+  let defs = "";
+  const index = content.indexOf("<" + tag);
+  while (index >= 0) {
+    const start = content.indexOf(">", index);
+    const end = content.indexOf("</" + tag);
+    if (start === -1 || end === -1)
+      break;
+    const endEnd = content.indexOf(">", end);
+    if (endEnd === -1)
+      break;
+    defs += content.slice(start + 1, end).trim();
+    content = content.slice(0, index).trim() + content.slice(endEnd + 1);
+  }
+  return {
+    defs,
+    content
+  };
+}
+function mergeDefsAndContent(defs, content) {
+  return defs ? "<defs>" + defs + "</defs>" + content : content;
+}
+function wrapSVGContent(body, start, end) {
+  const split = splitSVGDefs(body);
+  return mergeDefsAndContent(split.defs, start + split.content + end);
+}
+
+// node_modules/@iconify/utils/lib/svg/build.js
+var isUnsetKeyword = (value) => value === "unset" || value === "undefined" || value === "none";
+function iconToSVG(icon, customisations) {
+  const fullIcon = {
+    ...defaultIconProps,
+    ...icon
+  };
+  const fullCustomisations = {
+    ...defaultIconCustomisations,
+    ...customisations
+  };
+  const box = {
+    left: fullIcon.left,
+    top: fullIcon.top,
+    width: fullIcon.width,
+    height: fullIcon.height
+  };
+  let body = fullIcon.body;
+  [fullIcon, fullCustomisations].forEach((props) => {
+    const transformations = [];
+    const hFlip = props.hFlip;
+    const vFlip = props.vFlip;
+    let rotation = props.rotate;
+    if (hFlip)
+      if (vFlip)
+        rotation += 2;
+      else {
+        transformations.push("translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")");
+        transformations.push("scale(-1 1)");
+        box.top = box.left = 0;
+      }
+    else if (vFlip) {
+      transformations.push("translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")");
+      transformations.push("scale(1 -1)");
+      box.top = box.left = 0;
+    }
+    let tempValue;
+    if (rotation < 0)
+      rotation -= Math.floor(rotation / 4) * 4;
+    rotation = rotation % 4;
+    switch (rotation) {
+      case 1:
+        tempValue = box.height / 2 + box.top;
+        transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+      case 2:
+        transformations.unshift("rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")");
+        break;
+      case 3:
+        tempValue = box.width / 2 + box.left;
+        transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+    }
+    if (rotation % 2 === 1) {
+      if (box.left !== box.top) {
+        tempValue = box.left;
+        box.left = box.top;
+        box.top = tempValue;
+      }
+      if (box.width !== box.height) {
+        tempValue = box.width;
+        box.width = box.height;
+        box.height = tempValue;
+      }
+    }
+    if (transformations.length)
+      body = wrapSVGContent(body, '<g transform="' + transformations.join(" ") + '">', "</g>");
+  });
+  const customisationsWidth = fullCustomisations.width;
+  const customisationsHeight = fullCustomisations.height;
+  const boxWidth = box.width;
+  const boxHeight = box.height;
+  let width;
+  let height;
+  if (customisationsWidth === null) {
+    height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+    width = calculateSize(height, boxWidth / boxHeight);
+  } else {
+    width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+    height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+  }
+  const attributes = {};
+  const setAttr = (prop, value) => {
+    if (!isUnsetKeyword(value))
+      attributes[prop] = value.toString();
+  };
+  setAttr("width", width);
+  setAttr("height", height);
+  const viewBox = [
+    box.left,
+    box.top,
+    boxWidth,
+    boxHeight
+  ];
+  attributes.viewBox = viewBox.join(" ");
+  return {
+    attributes,
+    viewBox,
+    body
+  };
+}
+
+// node_modules/@iconify/utils/lib/svg/id.js
+var regex = /\sid="(\S+)"/g;
+var counters = /* @__PURE__ */ new Map;
+function nextID(id) {
+  id = id.replace(/[0-9]+$/, "") || "a";
+  const count = counters.get(id) || 0;
+  counters.set(id, count + 1);
+  return count ? `${id}${count}` : id;
+}
+function replaceIDs(body) {
+  const ids = [];
+  let match;
+  while (match = regex.exec(body))
+    ids.push(match[1]);
+  if (!ids.length)
+    return body;
+  const suffix = "suffix" + (Math.random() * 16777216 | Date.now()).toString(16);
+  ids.forEach((id) => {
+    const newID = nextID(id);
+    const escapedID = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    body = body.replace(new RegExp('([#;"])(' + escapedID + ')([")]|\\.[a-z])', "g"), "$1" + newID + suffix + "$3");
+  });
+  body = body.replace(new RegExp(suffix, "g"), "");
+  return body;
+}
+// node_modules/@iconify/utils/lib/svg/html.js
+function iconToHTML(body, attributes) {
+  let renderAttribsHTML = body.indexOf("xlink:") === -1 ? "" : ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+  for (const attr in attributes)
+    renderAttribsHTML += " " + attr + '="' + attributes[attr] + '"';
+  return '<svg xmlns="http://www.w3.org/2000/svg"' + renderAttribsHTML + ">" + body + "</svg>";
+}
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-4I5QYGJK.mjs
+var unknownIcon = {
+  body: '<g><rect width="80" height="80" style="fill: #087ebf; stroke-width: 0px;"/><text transform="translate(21.16 64.67)" style="fill: #fff; font-family: ArialMT, Arial; font-size: 67.75px;"><tspan x="0" y="0">?</tspan></text></g>',
+  height: 80,
+  width: 80
+};
+var iconsStore = /* @__PURE__ */ new Map;
+var loaderStore = /* @__PURE__ */ new Map;
+var registerIconPacks = /* @__PURE__ */ __name((iconLoaders) => {
+  for (const iconLoader of iconLoaders) {
+    if (!iconLoader.name) {
+      throw new Error('Invalid icon loader. Must have a "name" property with non-empty string value.');
+    }
+    log.debug("Registering icon pack:", iconLoader.name);
+    if ("loader" in iconLoader) {
+      loaderStore.set(iconLoader.name, iconLoader.loader);
+    } else if ("icons" in iconLoader) {
+      iconsStore.set(iconLoader.name, iconLoader.icons);
+    } else {
+      log.error("Invalid icon loader:", iconLoader);
+      throw new Error('Invalid icon loader. Must have either "icons" or "loader" property.');
+    }
+  }
+}, "registerIconPacks");
+var getRegisteredIconData = /* @__PURE__ */ __name(async (iconName, fallbackPrefix) => {
+  const data = stringToIcon(iconName, true, fallbackPrefix !== undefined);
+  if (!data) {
+    throw new Error(`Invalid icon name: ${iconName}`);
+  }
+  const prefix = data.prefix || fallbackPrefix;
+  if (!prefix) {
+    throw new Error(`Icon name must contain a prefix: ${iconName}`);
+  }
+  let icons = iconsStore.get(prefix);
+  if (!icons) {
+    const loader = loaderStore.get(prefix);
+    if (!loader) {
+      throw new Error(`Icon set not found: ${data.prefix}`);
+    }
+    try {
+      const loaded = await loader();
+      icons = { ...loaded, prefix };
+      iconsStore.set(prefix, icons);
+    } catch (e) {
+      log.error(e);
+      throw new Error(`Failed to load icon set: ${data.prefix}`);
+    }
+  }
+  const iconData = getIconData(icons, data.name);
+  if (!iconData) {
+    throw new Error(`Icon not found: ${iconName}`);
+  }
+  return iconData;
+}, "getRegisteredIconData");
+var isIconAvailable = /* @__PURE__ */ __name(async (iconName) => {
+  try {
+    await getRegisteredIconData(iconName);
+    return true;
+  } catch {
+    return false;
+  }
+}, "isIconAvailable");
+var getIconSVG = /* @__PURE__ */ __name(async (iconName, customisations, extraAttributes) => {
+  let iconData;
+  try {
+    iconData = await getRegisteredIconData(iconName, customisations?.fallbackPrefix);
+  } catch (e) {
+    log.error(e);
+    iconData = unknownIcon;
+  }
+  const renderData = iconToSVG(iconData, customisations);
+  const svg = iconToHTML(replaceIDs(renderData.body), {
+    ...renderData.attributes,
+    ...extraAttributes
+  });
+  return sanitizeText(svg, getConfig());
+}, "getIconSVG");
+
+export { unknownIcon, registerIconPacks, isIconAvailable, getIconSVG };