modern-idoc 0.5.6 → 0.6.1

package/dist/index.cjs

@@ -3,15 +3,45 @@
 const colord = require('colord');
 
 function normalizeAudio(audio) {
-  if (!audio || audio === "none") {
-    return void 0;
-  } else if (typeof audio === "string") {
+  if (typeof audio === "string") {
     return { src: audio };
   } else {
     return audio;
   }
 }
 
+function isNone(value) {
+  return value === null || value === void 0 || value === "none";
+}
+function round(number, digits = 0, base = 10 ** digits) {
+  return Math.round(base * number) / base + 0;
+}
+function clearUndef(obj, deep = false) {
+  if (typeof obj !== "object" || !obj) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    if (deep) {
+      return obj.map((v) => clearUndef(v, deep));
+    } else {
+      return obj;
+    }
+  }
+  const newObj = {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (deep) {
+      newObj[key] = clearUndef(value, deep);
+    } else {
+      newObj[key] = value;
+    }
+  }
+  return newObj;
+}
+
 function parseColor(color) {
   let input;
   if (typeof color === "number") {
@@ -26,9 +56,6 @@ function parseColor(color) {
   }
   return colord.colord(input);
 }
-function round(number, digits = 0, base = 10 ** digits) {
-  return Math.round(base * number) / base + 0;
-}
 function roundRgba(rgba) {
   return {
     r: round(rgba.r),
@@ -41,10 +68,11 @@ function format(number) {
   const hex = number.toString(16);
   return hex.length < 2 ? `0${hex}` : hex;
 }
+const defaultColor = "#000000FF";
+function isColor(value) {
+  return parseColor(value).isValid();
+}
 function normalizeColor(color, orFail = false) {
-  if (color === void 0 || color === "none") {
-    return void 0;
-  }
   const parsed = parseColor(color);
   if (!parsed.isValid()) {
     if (typeof color === "string") {
@@ -55,85 +83,720 @@ function normalizeColor(color, orFail = false) {
       throw new Error(message);
     } else {
       console.warn(message);
-      return "#000000FF";
+      return defaultColor;
     }
   }
   const { r, g, b, a } = roundRgba(parsed.rgba);
   return `#${format(r)}${format(g)}${format(b)}${format(round(a * 255))}`;
 }
 
-function normalizeFill(fill) {
-  if (!fill || fill === "none") {
-    return void 0;
-  } else if (typeof fill === "string") {
-    return { color: normalizeColor(fill) };
-  } else {
+var GradientParser$1 = GradientParser$1 || {};
+GradientParser$1.parse = /* @__PURE__ */ function() {
+  const tokens = {
+    linearGradient: /^(-(webkit|o|ms|moz)-)?(linear-gradient)/i,
+    repeatingLinearGradient: /^(-(webkit|o|ms|moz)-)?(repeating-linear-gradient)/i,
+    radialGradient: /^(-(webkit|o|ms|moz)-)?(radial-gradient)/i,
+    repeatingRadialGradient: /^(-(webkit|o|ms|moz)-)?(repeating-radial-gradient)/i,
+    sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
+    extentKeywords: /^(closest-side|closest-corner|farthest-side|farthest-corner|contain|cover)/,
+    positionKeywords: /^(left|center|right|top|bottom)/i,
+    pixelValue: /^(-?((\d*\.\d+)|(\d+\.?)))px/,
+    percentageValue: /^(-?((\d*\.\d+)|(\d+\.?)))%/,
+    emValue: /^(-?((\d*\.\d+)|(\d+\.?)))em/,
+    angleValue: /^(-?((\d*\.\d+)|(\d+\.?)))deg/,
+    radianValue: /^(-?((\d*\.\d+)|(\d+\.?)))rad/,
+    startCall: /^\(/,
+    endCall: /^\)/,
+    comma: /^,/,
+    hexColor: /^#([0-9a-f]+)/i,
+    literalColor: /^([a-z]+)/i,
+    rgbColor: /^rgb/i,
+    rgbaColor: /^rgba/i,
+    varColor: /^var/i,
+    calcValue: /^calc/i,
+    variableName: /^(--[a-z0-9-,\s#]+)/i,
+    number: /^((\d*\.\d+)|(\d+\.?))/,
+    hslColor: /^hsl/i,
+    hslaColor: /^hsla/i
+  };
+  let input = "";
+  function error(msg) {
+    const err = new Error(`${input}: ${msg}`);
+    err.source = input;
+    throw err;
+  }
+  function getAST() {
+    const ast = matchListDefinitions();
+    if (input.length > 0) {
+      error("Invalid input not EOF");
+    }
+    return ast;
+  }
+  function matchListDefinitions() {
+    return matchListing(matchDefinition);
+  }
+  function matchDefinition() {
+    return matchGradient(
+      "linear-gradient",
+      tokens.linearGradient,
+      matchLinearOrientation
+    ) || matchGradient(
+      "repeating-linear-gradient",
+      tokens.repeatingLinearGradient,
+      matchLinearOrientation
+    ) || matchGradient(
+      "radial-gradient",
+      tokens.radialGradient,
+      matchListRadialOrientations
+    ) || matchGradient(
+      "repeating-radial-gradient",
+      tokens.repeatingRadialGradient,
+      matchListRadialOrientations
+    );
+  }
+  function matchGradient(gradientType, pattern, orientationMatcher) {
+    return matchCall(pattern, (captures) => {
+      const orientation = orientationMatcher();
+      if (orientation) {
+        if (!scan(tokens.comma)) {
+          error("Missing comma before color stops");
+        }
+      }
+      return {
+        type: gradientType,
+        orientation,
+        colorStops: matchListing(matchColorStop)
+      };
+    });
+  }
+  function matchCall(pattern, callback) {
+    const captures = scan(pattern);
+    if (captures) {
+      if (!scan(tokens.startCall)) {
+        error("Missing (");
+      }
+      const result = callback(captures);
+      if (!scan(tokens.endCall)) {
+        error("Missing )");
+      }
+      return result;
+    }
+  }
+  function matchLinearOrientation() {
+    const sideOrCorner = matchSideOrCorner();
+    if (sideOrCorner) {
+      return sideOrCorner;
+    }
+    const legacyDirection = match("position-keyword", tokens.positionKeywords, 1);
+    if (legacyDirection) {
+      return {
+        type: "directional",
+        value: legacyDirection.value
+      };
+    }
+    return matchAngle();
+  }
+  function matchSideOrCorner() {
+    return match("directional", tokens.sideOrCorner, 1);
+  }
+  function matchAngle() {
+    return match("angular", tokens.angleValue, 1) || match("angular", tokens.radianValue, 1);
+  }
+  function matchListRadialOrientations() {
+    let radialOrientations;
+    let radialOrientation = matchRadialOrientation();
+    let lookaheadCache;
+    if (radialOrientation) {
+      radialOrientations = [];
+      radialOrientations.push(radialOrientation);
+      lookaheadCache = input;
+      if (scan(tokens.comma)) {
+        radialOrientation = matchRadialOrientation();
+        if (radialOrientation) {
+          radialOrientations.push(radialOrientation);
+        } else {
+          input = lookaheadCache;
+        }
+      }
+    }
+    return radialOrientations;
+  }
+  function matchRadialOrientation() {
+    let radialType = matchCircle() || matchEllipse();
+    if (radialType) {
+      radialType.at = matchAtPosition();
+    } else {
+      const extent = matchExtentKeyword();
+      if (extent) {
+        radialType = extent;
+        const positionAt = matchAtPosition();
+        if (positionAt) {
+          radialType.at = positionAt;
+        }
+      } else {
+        const atPosition = matchAtPosition();
+        if (atPosition) {
+          radialType = {
+            type: "default-radial",
+            at: atPosition
+          };
+        } else {
+          const defaultPosition = matchPositioning();
+          if (defaultPosition) {
+            radialType = {
+              type: "default-radial",
+              at: defaultPosition
+            };
+          }
+        }
+      }
+    }
+    return radialType;
+  }
+  function matchCircle() {
+    const circle = match("shape", /^(circle)/i, 0);
+    if (circle) {
+      circle.style = matchLength() || matchExtentKeyword();
+    }
+    return circle;
+  }
+  function matchEllipse() {
+    const ellipse = match("shape", /^(ellipse)/i, 0);
+    if (ellipse) {
+      ellipse.style = matchPositioning() || matchDistance() || matchExtentKeyword();
+    }
+    return ellipse;
+  }
+  function matchExtentKeyword() {
+    return match("extent-keyword", tokens.extentKeywords, 1);
+  }
+  function matchAtPosition() {
+    if (match("position", /^at/, 0)) {
+      const positioning = matchPositioning();
+      if (!positioning) {
+        error("Missing positioning value");
+      }
+      return positioning;
+    }
+  }
+  function matchPositioning() {
+    const location = matchCoordinates();
+    if (location.x || location.y) {
+      return {
+        type: "position",
+        value: location
+      };
+    }
+  }
+  function matchCoordinates() {
     return {
-      ...fill,
-      color: normalizeColor(fill.color)
+      x: matchDistance(),
+      y: matchDistance()
     };
   }
+  function matchListing(matcher) {
+    let captures = matcher();
+    const result = [];
+    if (captures) {
+      result.push(captures);
+      while (scan(tokens.comma)) {
+        captures = matcher();
+        if (captures) {
+          result.push(captures);
+        } else {
+          error("One extra comma");
+        }
+      }
+    }
+    return result;
+  }
+  function matchColorStop() {
+    const color = matchColor();
+    if (!color) {
+      error("Expected color definition");
+    }
+    color.length = matchDistance();
+    return color;
+  }
+  function matchColor() {
+    return matchHexColor() || matchHSLAColor() || matchHSLColor() || matchRGBAColor() || matchRGBColor() || matchVarColor() || matchLiteralColor();
+  }
+  function matchLiteralColor() {
+    return match("literal", tokens.literalColor, 0);
+  }
+  function matchHexColor() {
+    return match("hex", tokens.hexColor, 1);
+  }
+  function matchRGBColor() {
+    return matchCall(tokens.rgbColor, () => {
+      return {
+        type: "rgb",
+        value: matchListing(matchNumber)
+      };
+    });
+  }
+  function matchRGBAColor() {
+    return matchCall(tokens.rgbaColor, () => {
+      return {
+        type: "rgba",
+        value: matchListing(matchNumber)
+      };
+    });
+  }
+  function matchVarColor() {
+    return matchCall(tokens.varColor, () => {
+      return {
+        type: "var",
+        value: matchVariableName()
+      };
+    });
+  }
+  function matchHSLColor() {
+    return matchCall(tokens.hslColor, () => {
+      const lookahead = scan(tokens.percentageValue);
+      if (lookahead) {
+        error("HSL hue value must be a number in degrees (0-360) or normalized (-360 to 360), not a percentage");
+      }
+      const hue = matchNumber();
+      scan(tokens.comma);
+      let captures = scan(tokens.percentageValue);
+      const sat = captures ? captures[1] : null;
+      scan(tokens.comma);
+      captures = scan(tokens.percentageValue);
+      const light = captures ? captures[1] : null;
+      if (!sat || !light) {
+        error("Expected percentage value for saturation and lightness in HSL");
+      }
+      return {
+        type: "hsl",
+        value: [hue, sat, light]
+      };
+    });
+  }
+  function matchHSLAColor() {
+    return matchCall(tokens.hslaColor, () => {
+      const hue = matchNumber();
+      scan(tokens.comma);
+      let captures = scan(tokens.percentageValue);
+      const sat = captures ? captures[1] : null;
+      scan(tokens.comma);
+      captures = scan(tokens.percentageValue);
+      const light = captures ? captures[1] : null;
+      scan(tokens.comma);
+      const alpha = matchNumber();
+      if (!sat || !light) {
+        error("Expected percentage value for saturation and lightness in HSLA");
+      }
+      return {
+        type: "hsla",
+        value: [hue, sat, light, alpha]
+      };
+    });
+  }
+  function matchVariableName() {
+    return scan(tokens.variableName)[1];
+  }
+  function matchNumber() {
+    return scan(tokens.number)[1];
+  }
+  function matchDistance() {
+    return match("%", tokens.percentageValue, 1) || matchPositionKeyword() || matchCalc() || matchLength();
+  }
+  function matchPositionKeyword() {
+    return match("position-keyword", tokens.positionKeywords, 1);
+  }
+  function matchCalc() {
+    return matchCall(tokens.calcValue, () => {
+      let openParenCount = 1;
+      let i = 0;
+      while (openParenCount > 0 && i < input.length) {
+        const char = input.charAt(i);
+        if (char === "(") {
+          openParenCount++;
+        } else if (char === ")") {
+          openParenCount--;
+        }
+        i++;
+      }
+      if (openParenCount > 0) {
+        error("Missing closing parenthesis in calc() expression");
+      }
+      const calcContent = input.substring(0, i - 1);
+      consume(i - 1);
+      return {
+        type: "calc",
+        value: calcContent
+      };
+    });
+  }
+  function matchLength() {
+    return match("px", tokens.pixelValue, 1) || match("em", tokens.emValue, 1);
+  }
+  function match(type, pattern, captureIndex) {
+    const captures = scan(pattern);
+    if (captures) {
+      return {
+        type,
+        value: captures[captureIndex]
+      };
+    }
+  }
+  function scan(regexp) {
+    let captures, blankCaptures;
+    blankCaptures = /^\s+/.exec(input);
+    if (blankCaptures) {
+      consume(blankCaptures[0].length);
+    }
+    captures = regexp.exec(input);
+    if (captures) {
+      consume(captures[0].length);
+    }
+    return captures;
+  }
+  function consume(size) {
+    input = input.substr(size);
+  }
+  return function(code) {
+    input = code.toString().trim();
+    if (input.endsWith(";")) {
+      input = input.slice(0, -1);
+    }
+    return getAST();
+  };
+}();
+const parseGradient = GradientParser$1.parse.bind(GradientParser$1);
+
+var GradientParser = GradientParser || {};
+GradientParser.stringify = /* @__PURE__ */ function() {
+  var visitor = {
+    "visit_linear-gradient": function(node) {
+      return visitor.visit_gradient(node);
+    },
+    "visit_repeating-linear-gradient": function(node) {
+      return visitor.visit_gradient(node);
+    },
+    "visit_radial-gradient": function(node) {
+      return visitor.visit_gradient(node);
+    },
+    "visit_repeating-radial-gradient": function(node) {
+      return visitor.visit_gradient(node);
+    },
+    "visit_gradient": function(node) {
+      var orientation = visitor.visit(node.orientation);
+      if (orientation) {
+        orientation += ", ";
+      }
+      return node.type + "(" + orientation + visitor.visit(node.colorStops) + ")";
+    },
+    "visit_shape": function(node) {
+      var result = node.value, at = visitor.visit(node.at), style = visitor.visit(node.style);
+      if (style) {
+        result += " " + style;
+      }
+      if (at) {
+        result += " at " + at;
+      }
+      return result;
+    },
+    "visit_default-radial": function(node) {
+      var result = "", at = visitor.visit(node.at);
+      if (at) {
+        result += at;
+      }
+      return result;
+    },
+    "visit_extent-keyword": function(node) {
+      var result = node.value, at = visitor.visit(node.at);
+      if (at) {
+        result += " at " + at;
+      }
+      return result;
+    },
+    "visit_position-keyword": function(node) {
+      return node.value;
+    },
+    "visit_position": function(node) {
+      return visitor.visit(node.value.x) + " " + visitor.visit(node.value.y);
+    },
+    "visit_%": function(node) {
+      return node.value + "%";
+    },
+    "visit_em": function(node) {
+      return node.value + "em";
+    },
+    "visit_px": function(node) {
+      return node.value + "px";
+    },
+    "visit_calc": function(node) {
+      return "calc(" + node.value + ")";
+    },
+    "visit_literal": function(node) {
+      return visitor.visit_color(node.value, node);
+    },
+    "visit_hex": function(node) {
+      return visitor.visit_color("#" + node.value, node);
+    },
+    "visit_rgb": function(node) {
+      return visitor.visit_color("rgb(" + node.value.join(", ") + ")", node);
+    },
+    "visit_rgba": function(node) {
+      return visitor.visit_color("rgba(" + node.value.join(", ") + ")", node);
+    },
+    "visit_hsl": function(node) {
+      return visitor.visit_color("hsl(" + node.value[0] + ", " + node.value[1] + "%, " + node.value[2] + "%)", node);
+    },
+    "visit_hsla": function(node) {
+      return visitor.visit_color("hsla(" + node.value[0] + ", " + node.value[1] + "%, " + node.value[2] + "%, " + node.value[3] + ")", node);
+    },
+    "visit_var": function(node) {
+      return visitor.visit_color("var(" + node.value + ")", node);
+    },
+    "visit_color": function(resultColor, node) {
+      var result = resultColor, length = visitor.visit(node.length);
+      if (length) {
+        result += " " + length;
+      }
+      return result;
+    },
+    "visit_angular": function(node) {
+      return node.value + "deg";
+    },
+    "visit_directional": function(node) {
+      return "to " + node.value;
+    },
+    "visit_array": function(elements) {
+      var result = "", size = elements.length;
+      elements.forEach(function(element, i) {
+        result += visitor.visit(element);
+        if (i < size - 1) {
+          result += ", ";
+        }
+      });
+      return result;
+    },
+    "visit_object": function(obj) {
+      if (obj.width && obj.height) {
+        return visitor.visit(obj.width) + " " + visitor.visit(obj.height);
+      }
+      return "";
+    },
+    "visit": function(element) {
+      if (!element) {
+        return "";
+      }
+      if (element instanceof Array) {
+        return visitor.visit_array(element);
+      } else if (typeof element === "object" && !element.type) {
+        return visitor.visit_object(element);
+      } else if (element.type) {
+        var nodeVisitor = visitor["visit_" + element.type];
+        if (nodeVisitor) {
+          return nodeVisitor(element);
+        } else {
+          throw Error("Missing visitor visit_" + element.type);
+        }
+      } else {
+        throw Error("Invalid node.");
+      }
+    }
+  };
+  return function(root) {
+    return visitor.visit(root);
+  };
+}();
+const stringifyGradient = GradientParser.stringify.bind(GradientParser);
+
+function parseColorStopNodeList(colorStops) {
+  const count = colorStops.length - 1;
+  return colorStops.map((stop, index) => {
+    const value = stop.value;
+    let offset = round(index / count, 3);
+    let color = "#00000000";
+    switch (stop.type) {
+      case "rgb":
+        color = normalizeColor({
+          r: Number(value[0] ?? 0),
+          g: Number(value[1] ?? 0),
+          b: Number(value[2] ?? 0)
+        });
+        break;
+      case "rgba":
+        color = normalizeColor({
+          r: Number(value[0] ?? 0),
+          g: Number(value[1] ?? 0),
+          b: Number(value[2] ?? 0),
+          a: Number(value[3] ?? 0)
+        });
+        break;
+      case "literal":
+        color = normalizeColor(stop.value);
+        break;
+      case "hex":
+        color = normalizeColor(stop.value);
+        break;
+    }
+    switch (stop.length?.type) {
+      case "%":
+        offset = Number(stop.length.value) / 100;
+        break;
+    }
+    return { offset, color };
+  });
+}
+function parseLinearGradientNode(node) {
+  let angle = 0;
+  switch (node.orientation?.type) {
+    case "angular":
+      angle = Number(node.orientation.value);
+      break;
+  }
+  return {
+    type: "linear-gradient",
+    angle,
+    stops: parseColorStopNodeList(node.colorStops)
+  };
+}
+function parseRadialGradientNode(node) {
+  node.orientation?.map((item) => {
+    switch (item?.type) {
+      case "shape":
+      case "default-radial":
+      case "extent-keyword":
+      default:
+        return null;
+    }
+  });
+  return {
+    type: "radial-gradient",
+    stops: parseColorStopNodeList(node.colorStops)
+  };
+}
+function isGradient(cssText) {
+  return cssText.startsWith("linear-gradient") || cssText.startsWith("radial-gradient");
+}
+function normalizeGradient(cssText) {
+  return parseGradient(cssText).map((node) => {
+    switch (node?.type) {
+      case "linear-gradient":
+        return parseLinearGradientNode(node);
+      case "repeating-linear-gradient":
+        return { ...parseLinearGradientNode(node), repeat: true };
+      case "radial-gradient":
+        return parseRadialGradientNode(node);
+      case "repeating-radial-gradient":
+        return { ...parseRadialGradientNode(node), repeat: true };
+      default:
+        return void 0;
+    }
+  }).filter(Boolean);
 }
 
-function normalizeBackground(background) {
-  if (!background || background === "none") {
-    return void 0;
-  } else if (typeof background === "string") {
-    return { src: background };
+function normalizeColorFill(fill) {
+  let obj;
+  if (typeof fill === "string") {
+    obj = { color: fill };
   } else {
-    return {
-      ...background,
-      ...normalizeFill(background)
-    };
+    obj = fill;
   }
+  return {
+    color: normalizeColor(obj.color)
+  };
 }
 
-function clearUndef(obj, deep = false) {
-  if (typeof obj !== "object" || !obj) {
-    return obj;
+function normalizeGradientFill(fill) {
+  let obj;
+  if (typeof fill === "string") {
+    obj = { image: fill };
+  } else {
+    obj = fill;
   }
-  if (Array.isArray(obj)) {
-    if (deep) {
-      return obj.map((v) => clearUndef(v, deep));
-    } else {
-      return obj;
-    }
+  const res = normalizeGradient(obj.image)[0];
+  switch (res?.type) {
+    case "radial-gradient":
+      return {
+        radialGradient: res
+      };
+    case "linear-gradient":
+      return {
+        linearGradient: res
+      };
   }
-  const newObj = {};
-  for (const key in obj) {
-    const value = obj[key];
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (deep) {
-      newObj[key] = clearUndef(value, deep);
+  return {};
+}
+
+function normalizeImageFill(fill) {
+  return fill;
+}
+
+function normalizePresetFill(fill) {
+  let obj;
+  if (typeof fill === "string") {
+    obj = { preset: fill };
+  } else {
+    obj = fill;
+  }
+  return {
+    preset: obj.preset,
+    foregroundColor: isNone(obj.foregroundColor) ? void 0 : normalizeColor(obj.foregroundColor),
+    backgroundColor: isNone(obj.backgroundColor) ? void 0 : normalizeColor(obj.backgroundColor)
+  };
+}
+
+function normalizeFill(fill) {
+  if (typeof fill === "string") {
+    if (isColor(fill)) {
+      return normalizeColorFill({ color: fill });
+    } else if (isGradient(fill)) {
+      return normalizeGradientFill({ image: fill });
     } else {
-      newObj[key] = value;
+      return normalizeImageFill({ image: fill });
+    }
+  } else {
+    if (!isNone(fill.color)) {
+      return normalizeColorFill(fill);
+    } else if (!isNone(fill.image)) {
+      if (isGradient(fill.image)) {
+        return normalizeGradientFill(fill);
+      } else {
+        return normalizeImageFill(fill);
+      }
+    } else if (isNone(fill.preset)) {
+      return normalizePresetFill(fill);
     }
   }
-  return newObj;
+  throw new Error("Unknown fill property object");
+}
+
+function normalizeBackground(background) {
+  if (typeof background === "string") {
+    return {
+      ...normalizeFill(background),
+      fillWithShape: false
+    };
+  } else {
+    return {
+      ...normalizeFill(background),
+      fillWithShape: Boolean(background.fillWithShape)
+    };
+  }
 }
 
 function getDefaultInnerShadow() {
   return {
-    color: "rgb(0, 0, 0)",
+    color: defaultColor,
     offsetX: 0,
     offsetY: 0,
     blurRadius: 1
   };
 }
 function normalizeInnerShadow(shadow) {
-  if (!shadow || shadow === "none") {
-    return void 0;
-  } else {
-    return {
-      ...getDefaultInnerShadow(),
-      ...clearUndef({
-        ...shadow,
-        color: normalizeColor(shadow.color)
-      })
-    };
-  }
+  return {
+    ...getDefaultInnerShadow(),
+    ...clearUndef({
+      ...shadow,
+      color: isNone(shadow.color) ? defaultColor : normalizeColor(shadow.color)
+    })
+  };
 }
 
 function getDefaultOuterShadow() {
@@ -144,101 +807,61 @@ function getDefaultOuterShadow() {
   };
 }
 function normalizeOuterShadow(shadow) {
-  if (!shadow || shadow === "none") {
-    return void 0;
-  } else {
-    return {
-      ...getDefaultOuterShadow(),
-      ...normalizeInnerShadow(shadow)
-    };
-  }
+  return {
+    ...getDefaultOuterShadow(),
+    ...normalizeInnerShadow(shadow)
+  };
 }
 
 function normalizeSoftEdge(softEdge) {
-  if (!softEdge || softEdge === "none") {
-    return void 0;
-  } else {
-    return softEdge;
-  }
+  return softEdge;
 }
 
 function normalizeEffect(effect) {
-  if (!effect || effect === "none") {
-    return void 0;
-  } else {
-    return clearUndef({
-      ...effect,
-      softEdge: normalizeSoftEdge(effect.softEdge),
-      outerShadow: normalizeOuterShadow(effect.outerShadow),
-      innerShadow: normalizeInnerShadow(effect.innerShadow)
-    });
-  }
+  return clearUndef({
+    ...effect,
+    softEdge: isNone(effect.softEdge) ? void 0 : normalizeSoftEdge(effect.softEdge),
+    outerShadow: isNone(effect.outerShadow) ? void 0 : normalizeOuterShadow(effect.outerShadow),
+    innerShadow: isNone(effect.innerShadow) ? void 0 : normalizeInnerShadow(effect.innerShadow)
+  });
 }
 
 function normalizeForeground(foreground) {
-  if (!foreground || foreground === "none") {
-    return void 0;
-  } else if (typeof foreground === "string") {
-    return { src: foreground };
-  } else {
-    return {
-      ...foreground,
-      ...normalizeFill(foreground)
-    };
-  }
-}
-
-function normalizeGeometry(geometry) {
-  if (!geometry || geometry === "none") {
-    return void 0;
-  } else if (typeof geometry === "string") {
+  if (typeof foreground === "string") {
     return {
-      paths: [
-        { data: geometry }
-      ]
+      ...normalizeFill(foreground),
+      fillWithShape: false
     };
-  } else if (Array.isArray(geometry)) {
+  } else {
     return {
-      paths: geometry.map((data) => {
-        if (typeof data === "string") {
-          return {
-            data
-          };
-        }
-        return data;
-      })
+      ...normalizeFill(foreground),
+      fillWithShape: Boolean(foreground.fillWithShape)
     };
-  } else {
-    return geometry;
   }
 }
 
 function normalizeOutline(outline) {
-  if (!outline || outline === "none") {
-    return void 0;
-  } else if (typeof outline === "string") {
+  if (typeof outline === "string") {
     return {
       color: normalizeColor(outline)
     };
   } else {
     return {
       ...outline,
-      color: normalizeColor(outline.color)
+      color: isNone(outline.color) ? void 0 : normalizeColor(outline.color)
     };
   }
 }
 
 function normalizeShadow(shadow) {
-  if (!shadow || shadow === "none") {
-    return void 0;
-  } else if (typeof shadow === "string") {
+  if (typeof shadow === "string") {
     return {
       color: normalizeColor(shadow)
     };
   } else {
     return {
       ...shadow,
-      color: normalizeColor(shadow.color)
+      color: isNone(shadow.color) ? defaultColor : normalizeColor(shadow.color)
     };
   }
 }
@@ -248,6 +871,29 @@ function getDefaultShadowStyle() {
   };
 }
 
+function normalizeShape(shape) {
+  if (typeof shape === "string") {
+    return {
+      paths: [
+        { data: shape }
+      ]
+    };
+  } else if (Array.isArray(shape)) {
+    return {
+      paths: shape.map((data) => {
+        if (typeof data === "string") {
+          return {
+            data
+          };
+        }
+        return data;
+      })
+    };
+  } else {
+    return shape;
+  }
+}
+
 function getDefaultLayoutStyle() {
   return {
     // box
@@ -408,16 +1054,13 @@ function getDefaultTextStyle() {
 }
 
 function normalizeStyle(style) {
-  if (!style || style === "none") {
-    return void 0;
-  }
   return clearUndef({
     ...style,
-    color: normalizeColor(style.color),
-    backgroundColor: normalizeColor(style.backgroundColor),
-    borderColor: normalizeColor(style.borderColor),
-    outlineColor: normalizeColor(style.outlineColor),
-    shadowColor: normalizeColor(style.shadowColor)
+    color: isNone(style.color) ? void 0 : normalizeColor(style.color),
+    backgroundColor: isNone(style.backgroundColor) ? void 0 : normalizeColor(style.backgroundColor),
+    borderColor: isNone(style.borderColor) ? void 0 : normalizeColor(style.borderColor),
+    outlineColor: isNone(style.outlineColor) ? void 0 : normalizeColor(style.outlineColor),
+    shadowColor: isNone(style.shadowColor) ? void 0 : normalizeColor(style.shadowColor)
   });
 }
 function getDefaultStyle() {
@@ -467,9 +1110,7 @@ function normalizeTextContent(content = "") {
   });
 }
 function normalizeText(text) {
-  if (!text || text === "none") {
-    return void 0;
-  } else if (typeof text === "string") {
+  if (typeof text === "string") {
     return {
       content: [
         {
@@ -492,9 +1133,7 @@ function normalizeText(text) {
 }
 
 function normalizeVideo(video) {
-  if (!video || video === "none") {
-    return void 0;
-  } else if (typeof video === "string") {
+  if (typeof video === "string") {
     return { src: video };
   } else {
     return video;
@@ -504,17 +1143,17 @@ function normalizeVideo(video) {
 function normalizeElement(element) {
   return clearUndef({
     ...element,
-    style: normalizeStyle(element.style),
-    text: normalizeText(element.text),
-    background: normalizeBackground(element.background),
-    geometry: normalizeGeometry(element.geometry),
-    fill: normalizeFill(element.fill),
-    outline: normalizeOutline(element.outline),
-    foreground: normalizeForeground(element.foreground),
-    shadow: normalizeShadow(element.shadow),
-    video: normalizeVideo(element.video),
-    audio: normalizeAudio(element.audio),
-    effect: normalizeEffect(element.effect),
+    style: isNone(element.style) ? void 0 : normalizeStyle(element.style),
+    text: isNone(element.text) ? void 0 : normalizeText(element.text),
+    background: isNone(element.background) ? void 0 : normalizeBackground(element.background),
+    shape: isNone(element.shape) ? void 0 : normalizeShape(element.shape),
+    fill: isNone(element.fill) ? void 0 : normalizeFill(element.fill),
+    outline: isNone(element.outline) ? void 0 : normalizeOutline(element.outline),
+    foreground: isNone(element.foreground) ? void 0 : normalizeForeground(element.foreground),
+    shadow: isNone(element.shadow) ? void 0 : normalizeShadow(element.shadow),
+    video: isNone(element.video) ? void 0 : normalizeVideo(element.video),
+    audio: isNone(element.audio) ? void 0 : normalizeAudio(element.audio),
+    effect: isNone(element.effect) ? void 0 : normalizeEffect(element.effect),
     children: element.children?.map((child) => normalizeElement(child))
   });
 }
@@ -524,6 +1163,7 @@ function normalizeDocument(doc) {
 }
 
 exports.clearUndef = clearUndef;
+exports.defaultColor = defaultColor;
 exports.getDefaultElementStyle = getDefaultElementStyle;
 exports.getDefaultHighlightStyle = getDefaultHighlightStyle;
 exports.getDefaultInnerShadow = getDefaultInnerShadow;
@@ -536,22 +1176,33 @@ exports.getDefaultTextInlineStyle = getDefaultTextInlineStyle;
 exports.getDefaultTextLineStyle = getDefaultTextLineStyle;
 exports.getDefaultTextStyle = getDefaultTextStyle;
 exports.getDefaultTransformStyle = getDefaultTransformStyle;
+exports.isColor = isColor;
+exports.isGradient = isGradient;
+exports.isNone = isNone;
 exports.normalizeAudio = normalizeAudio;
 exports.normalizeBackground = normalizeBackground;
 exports.normalizeColor = normalizeColor;
+exports.normalizeColorFill = normalizeColorFill;
 exports.normalizeDocument = normalizeDocument;
 exports.normalizeEffect = normalizeEffect;
 exports.normalizeElement = normalizeElement;
 exports.normalizeFill = normalizeFill;
 exports.normalizeForeground = normalizeForeground;
-exports.normalizeGeometry = normalizeGeometry;
+exports.normalizeGradient = normalizeGradient;
+exports.normalizeGradientFill = normalizeGradientFill;
+exports.normalizeImageFill = normalizeImageFill;
 exports.normalizeInnerShadow = normalizeInnerShadow;
 exports.normalizeOuterShadow = normalizeOuterShadow;
 exports.normalizeOutline = normalizeOutline;
+exports.normalizePresetFill = normalizePresetFill;
 exports.normalizeShadow = normalizeShadow;
+exports.normalizeShape = normalizeShape;
 exports.normalizeSoftEdge = normalizeSoftEdge;
 exports.normalizeStyle = normalizeStyle;
 exports.normalizeText = normalizeText;
 exports.normalizeTextContent = normalizeTextContent;
 exports.normalizeVideo = normalizeVideo;
 exports.parseColor = parseColor;
+exports.parseGradient = parseGradient;
+exports.round = round;
+exports.stringifyGradient = stringifyGradient;