modern-idoc 0.5.6 → 0.6.0

package/dist/index.cjs

@@ -3,9 +3,7 @@
 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;
@@ -41,10 +39,8 @@ function format(number) {
   const hex = number.toString(16);
   return hex.length < 2 ? `0${hex}` : hex;
 }
+const defaultColor = "#000000FF";
 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,39 +51,645 @@ 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);
 
-function normalizeBackground(background) {
-  if (!background || background === "none") {
-    return void 0;
-  } else if (typeof background === "string") {
-    return { src: background };
-  } else {
-    return {
-      ...background,
-      ...normalizeFill(background)
-    };
+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 parseLinearGradientNode(node) {
+  let angle = 0;
+  switch (node.orientation?.type) {
+    case "angular":
+      angle = Number(node.orientation.value);
+      break;
   }
+  const stops = node.colorStops.map((stop) => {
+    const value = stop.value;
+    let offset = 0;
+    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 };
+  });
+  return {
+    type: "linear-gradient",
+    angle,
+    stops
+  };
+}
+function parseRadialGradientNode(ast) {
+  ast.orientation?.map((item) => {
+    switch (item?.type) {
+      case "shape":
+      case "default-radial":
+      case "extent-keyword":
+      default:
+        return null;
+    }
+  });
+  const stops = ast.colorStops.map((stop) => {
+    const value = stop.value;
+    let offset = 0;
+    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 };
+  });
+  return {
+    type: "radial-gradient",
+    stops
+  };
+}
+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 isNone(value) {
+  return value === null || value === void 0 || value === "none";
+}
 function clearUndef(obj, deep = false) {
   if (typeof obj !== "object" || !obj) {
     return obj;
@@ -114,26 +716,44 @@ function clearUndef(obj, deep = false) {
   return newObj;
 }
 
+function normalizeFill(fill) {
+  if (typeof fill === "string") {
+    return { color: normalizeColor(fill) };
+  } else {
+    return {
+      ...fill,
+      color: isNone(fill.color) ? void 0 : normalizeColor(fill.color)
+    };
+  }
+}
+
+function normalizeBackground(background) {
+  if (typeof background === "string") {
+    return { src: background };
+  } else {
+    return {
+      ...background,
+      ...normalizeFill(background)
+    };
+  }
+}
+
 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,41 +764,27 @@ 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") {
+  if (typeof foreground === "string") {
     return { src: foreground };
   } else {
     return {
@@ -189,9 +795,7 @@ function normalizeForeground(foreground) {
 }
 
 function normalizeGeometry(geometry) {
-  if (!geometry || geometry === "none") {
-    return void 0;
-  } else if (typeof geometry === "string") {
+  if (typeof geometry === "string") {
     return {
       paths: [
         { data: geometry }
@@ -214,31 +818,27 @@ function normalizeGeometry(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)
     };
   }
 }
@@ -408,16 +1008,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 +1064,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 +1087,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 +1097,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),
+    geometry: isNone(element.geometry) ? void 0 : normalizeGeometry(element.geometry),
+    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 +1117,7 @@ function normalizeDocument(doc) {
 }
 
 exports.clearUndef = clearUndef;
+exports.defaultColor = defaultColor;
 exports.getDefaultElementStyle = getDefaultElementStyle;
 exports.getDefaultHighlightStyle = getDefaultHighlightStyle;
 exports.getDefaultInnerShadow = getDefaultInnerShadow;
@@ -536,6 +1130,7 @@ exports.getDefaultTextInlineStyle = getDefaultTextInlineStyle;
 exports.getDefaultTextLineStyle = getDefaultTextLineStyle;
 exports.getDefaultTextStyle = getDefaultTextStyle;
 exports.getDefaultTransformStyle = getDefaultTransformStyle;
+exports.isNone = isNone;
 exports.normalizeAudio = normalizeAudio;
 exports.normalizeBackground = normalizeBackground;
 exports.normalizeColor = normalizeColor;
@@ -545,6 +1140,7 @@ exports.normalizeElement = normalizeElement;
 exports.normalizeFill = normalizeFill;
 exports.normalizeForeground = normalizeForeground;
 exports.normalizeGeometry = normalizeGeometry;
+exports.normalizeGradient = normalizeGradient;
 exports.normalizeInnerShadow = normalizeInnerShadow;
 exports.normalizeOuterShadow = normalizeOuterShadow;
 exports.normalizeOutline = normalizeOutline;
@@ -555,3 +1151,5 @@ exports.normalizeText = normalizeText;
 exports.normalizeTextContent = normalizeTextContent;
 exports.normalizeVideo = normalizeVideo;
 exports.parseColor = parseColor;
+exports.parseGradient = parseGradient;
+exports.stringifyGradient = stringifyGradient;