modern-canvas 0.7.14 → 0.8.0

package/dist/index.cjs

@@ -5,7 +5,6 @@ const colord = require('colord');
 const namesPlugin = require('colord/plugins/names');
 const modernPath2d = require('modern-path2d');
 const modernText = require('modern-text');
-const load = require('yoga-layout/load');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -1746,7 +1745,7 @@ class Matrix3 extends Matrix {
   constructor(array) {
     super(3, 3, array);
   }
-  invert() {
+  affineInvert() {
     const [
       n11,
       n21,
@@ -2198,10 +2197,10 @@ class Transform2D extends Matrix3 {
     newPos.y = b * x + d * y + ty;
     return newPos;
   }
-  inverse() {
-    return this.clone().invert();
+  affineInverse() {
+    return this.clone().affineInvert();
   }
-  applyInverse(pos, newPos) {
+  applyAffineInverse(pos, newPos) {
     newPos = newPos || new Vector2();
     const { a, b, c, d, tx, ty } = this.toObject();
     const id = 1 / (a * d + c * -b);
@@ -2580,8 +2579,10 @@ attribute vec4 aBackgroundColor;
 attribute vec4 aDisableWrapMode;
 
 uniform mat3 projectionMatrix;
-uniform mat3 worldTransformMatrix;
+uniform mat3 viewMatrix;
 uniform vec4 modulate;
+uniform float canvasWidth;
+uniform float canvasHeight;
 
 varying float vTextureId;
 varying vec2 vUv;
@@ -2589,6 +2590,10 @@ varying vec4 vModulate;
 varying vec4 vBackgroundColor;
 varying vec4 vDisableWrapMode;
 
+vec2 roundPixels(vec2 position, vec2 targetSize) {
+  return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0;
+}
+
 void main(void) {
   mat3 modelMatrix = mat3(
     1.0, 0.0, 0.0,
@@ -2596,8 +2601,9 @@ void main(void) {
     0.0, 0.0, 1.0
   );
   vTextureId = aTextureId;
-  mat3 modelViewProjectionMatrix = projectionMatrix * worldTransformMatrix * modelMatrix;
-  gl_Position = vec4((modelViewProjectionMatrix * vec3(aPosition, 1.0)).xy, 0.0, 1.0);
+  vec3 pos = projectionMatrix * viewMatrix * modelMatrix * vec3(aPosition, 1.0);
+  gl_Position = vec4(roundPixels(pos.xy, vec2(canvasWidth, canvasHeight)), 0.0, 1.0);
+
   vUv = aUv;
   vModulate = aModulate * modulate;
   vBackgroundColor = aBackgroundColor;
@@ -2682,6 +2688,8 @@ void main(void) {
         renderer2.program.updateUniforms(program, {
           samplers,
           modulate: [1, 1, 1, 1],
+          canvasWidth: renderer2.gl.drawingBufferWidth,
+          canvasHeight: renderer2.gl.drawingBufferHeight,
           ...renderer2.program.uniforms
         });
         renderer2.vertexArray.bind(vao ?? vertexArray);
@@ -3327,7 +3335,7 @@ class WebGLProgramModule extends WebGLModule {
   boundProgram = null;
   uniforms = {
     projectionMatrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
-    worldTransformMatrix: [1, 0, 0, 0, 1, 0, 0, 0, 1]
+    viewMatrix: [1, 0, 0, 0, 1, 0, 0, 0, 1]
   };
   create(options) {
     const program = this.gl.createProgram();
@@ -3531,7 +3539,7 @@ ${gl.getShaderInfoLog(shader)}`);
     this.boundProgram = null;
     this.uniforms = {
       projectionMatrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
-      worldTransformMatrix: [1, 0, 0, 0, 1, 0, 0, 0, 1]
+      viewMatrix: [1, 0, 0, 0, 1, 0, 0, 0, 1]
     };
   }
   free() {
@@ -3625,8 +3633,8 @@ class WebGLScissorModule extends WebGLModule {
   use() {
     const renderer = this._renderer;
     const { pixelRatio, mask, viewport, screen, gl, program } = renderer;
-    const { worldTransformMatrix } = program.uniforms;
-    const rect = transformRectToAABB(worldTransformMatrix, mask.last.mask);
+    const { viewMatrix } = program.uniforms;
+    const rect = transformRectToAABB(viewMatrix, mask.last.mask);
     const { x, y, width, height } = rect;
     let scissorY;
     if (viewport.boundViewport) {
@@ -6565,7 +6573,7 @@ exports.Viewport = class Viewport extends exports.Node {
     this.projection.flipY(flipY);
   }
   projection = new Projection2D();
-  worldTransform = new Transform2D();
+  canvasTransform = new Transform2D();
   _framebufferIndex = 0;
   _framebuffers = [
     { texture: new ViewportTexture(), needsUpload: false },
@@ -6680,7 +6688,7 @@ exports.Viewport = class Viewport extends exports.Node {
   render(renderer, next) {
     const oldViewport = this._tree?.getCurrentViewport();
     renderer.program.uniforms.projectionMatrix = this.projection.toArray(true);
-    renderer.program.uniforms.worldTransformMatrix = this.worldTransform.toArray(true);
+    renderer.program.uniforms.viewMatrix = this.canvasTransform.toArray(true);
     this.activate(renderer);
     renderer.clear();
     super.render(renderer, next);
@@ -6695,11 +6703,11 @@ exports.Viewport = class Viewport extends exports.Node {
   getRect() {
     return new Rect2(this.x, this.y, this.width, this.height);
   }
-  toGlobal(worldPos, newPos) {
-    return this.worldTransform.applyInverse(worldPos, newPos);
+  toCanvasGlobal(screenPos, newPos) {
+    return this.canvasTransform.applyAffineInverse(screenPos, newPos);
   }
-  toWorld(globalPos, newPos) {
-    return this.worldTransform.apply(globalPos, newPos);
+  toCanvasScreen(globalPos, newPos) {
+    return this.canvasTransform.apply(globalPos, newPos);
   }
 };
 __decorateClass$P([
@@ -7237,35 +7245,28 @@ exports.Node2D = class Node2D extends exports.CanvasItem {
   getTransformOrigin() {
     return new Vector2(0, 0);
   }
-  getTransform(cb) {
+  updateTransform(cb) {
     const origin = this.getTransformOrigin();
-    const transform = new Transform2D();
-    transform.translate(-origin.x, -origin.y).scale(this.scale.x, this.scale.y).skew(this.skew.x, this.skew.y).rotate(this.rotation);
+    const transform = this.transform.identity().translate(-origin.x, -origin.y).scale(this.scale.x, this.scale.y).skew(this.skew.x, this.skew.y).rotate(this.rotation);
     cb?.(transform);
     transform.translate(this.position.x, this.position.y).translate(origin.x, origin.y);
-    return transform;
-  }
-  updateTransform() {
-    this.transform.copy(this.getTransform());
   }
   updateGlobalTransform() {
     this.updateTransform();
     const parent = this.getParent();
     if (parent?.globalTransform) {
-      this._parentTransformDirtyId = parent.globalTransform.dirtyId;
-      this.globalPosition.set(
-        parent.globalPosition.x + this.position.x,
-        parent.globalPosition.y + this.position.y
-      );
-      this.globalScale.set(
-        parent.globalScale.x * this.scale.x,
-        parent.globalScale.y * this.scale.y
-      );
-      this.globalSkew.set(
-        parent.globalSkew.x * this.skew.x,
-        parent.globalSkew.y * this.skew.y
-      );
-      this.globalRotation = parent.globalRotation + this.rotation;
+      const {
+        globalPosition,
+        globalScale,
+        globalSkew,
+        globalTransform,
+        globalRotation
+      } = parent;
+      this._parentTransformDirtyId = globalTransform.dirtyId;
+      this.globalPosition.set(globalPosition.x + this.position.x, globalPosition.y + this.position.y);
+      this.globalScale.set(globalScale.x * this.scale.x, globalScale.y * this.scale.y);
+      this.globalSkew.set(globalSkew.x * this.skew.x, globalSkew.y * this.skew.y);
+      this.globalRotation = globalRotation + this.rotation;
       parent.globalTransform.multiply(this.transform, this.globalTransform);
     } else {
       this.globalPosition.copy(this.position);
@@ -7314,7 +7315,7 @@ exports.Node2D = class Node2D extends exports.CanvasItem {
     }
   }
   toLocal(globalPos, newPos) {
-    return this.globalTransform.applyInverse(globalPos, newPos);
+    return this.globalTransform.applyAffineInverse(globalPos, newPos);
   }
   toGlobal(localPos, newPos) {
     return this.globalTransform.apply(localPos, newPos);
@@ -7341,7 +7342,7 @@ var __decorateClass$I = (decorators, target, key, kind) => {
   return result;
 };
 exports.Camera2D = class Camera2D extends exports.Node2D {
-  zoom = new Vector2(1, 1).on("update", () => this.updateWorldTransform());
+  zoom = new Vector2(1, 1).on("update", () => this.updateCanvasTransform());
   maxZoom = new Vector2(6, 6);
   minZoom = new Vector2(0.1, 0.1);
   _screenOffset = { x: 0, y: 0 };
@@ -7428,14 +7429,26 @@ exports.Camera2D = class Camera2D extends exports.Node2D {
   }
   updateTransform() {
     super.updateTransform();
-    this.updateWorldTransform();
+    this.updateCanvasTransform();
   }
-  updateWorldTransform() {
+  updateCanvasTransform() {
     const viewport = this.getViewport();
     if (!viewport)
       return;
-    viewport.worldTransform.identity().scale(this.zoom.x, this.zoom.y).translate(this.position.x, this.position.y);
-    this.emit("updateWorldTransform");
+    viewport.canvasTransform.identity().scale(this.zoom.x, this.zoom.y).translate(this.position.x, this.position.y);
+    this.emit("updateCanvasTransform");
+  }
+  toGlobal(screenPos, newPos) {
+    const viewport = this.getViewport();
+    if (!viewport)
+      throw new Error("Failed to toGlobal, viewport is empty");
+    return viewport.toCanvasGlobal(screenPos, newPos);
+  }
+  toScreen(globalPos, newPos) {
+    const viewport = this.getViewport();
+    if (!viewport)
+      throw new Error("Failed to toScreen, viewport is empty");
+    return viewport.toCanvasScreen(globalPos, newPos);
   }
 };
 __decorateClass$I([
@@ -10038,9 +10051,9 @@ exports.BaseElement2D = class BaseElement2D extends exports.Node2D {
     const [originX, originY] = parseCSSTransformOrigin(this.style.transformOrigin);
     return new Vector2(originX * width, originY * height);
   }
-  getTransform(cb) {
+  updateTransform(cb) {
     const { width, height } = this.size;
-    return super.getTransform((transform) => {
+    super.updateTransform((transform) => {
       parseCSSTransform(this.style.transform ?? "", width, height, transform);
       cb?.(transform);
     });
@@ -10229,7 +10242,7 @@ exports.BaseElement2D = class BaseElement2D extends exports.Node2D {
             const pos = new Vector2(screenX, screenY);
             const viewport = this.getViewport();
             if (viewport) {
-              viewport.toGlobal(pos, pos);
+              viewport.toCanvasGlobal(pos, pos);
             }
             this.toLocal(pos, pos);
             if (this._positionInput(pos, key)) {
@@ -10345,59 +10358,123 @@ exports.Element2D = __decorateClass$k([
   customNode("Element2D")
 ], exports.Element2D);
 
+const edgeMap = {
+  left: 0,
+  // Edge.Left
+  top: 1,
+  // Edge.Top
+  right: 2,
+  // Edge.Right
+  bottom: 3,
+  // Edge.Bottom
+  start: 4,
+  // Edge.Start
+  end: 5,
+  // Edge.End
+  horizontal: 6,
+  // Edge.Horizontal
+  vertical: 7,
+  // Edge.Vertical
+  all: 8
+  // Edge.All
+};
+const gutterMap = {
+  column: 0,
+  // Gutter.Column
+  row: 1,
+  // Gutter.Row
+  all: 2
+  // Gutter.All
+};
 const alignMap = {
-  "auto": load.Align.Auto,
-  "flex-start": load.Align.FlexStart,
-  "center": load.Align.Center,
-  "flex-end": load.Align.FlexEnd,
-  "stretch": load.Align.Stretch,
-  "baseline": load.Align.Baseline,
-  "space-between": load.Align.SpaceBetween,
-  "space-around": load.Align.SpaceAround,
-  "space-evenly": load.Align.SpaceEvenly
+  "auto": 0,
+  // Align.Auto
+  "flex-start": 1,
+  // Align.FlexStart
+  "center": 2,
+  // Align.Center
+  "flex-end": 3,
+  // Align.FlexEnd
+  "stretch": 4,
+  // Align.Stretch
+  "baseline": 5,
+  // Align.Baseline
+  "space-between": 6,
+  // Align.SpaceBetween
+  "space-around": 7,
+  // Align.SpaceAround
+  "space-evenly": 8
+  // Align.SpaceEvenly
 };
 const displayMap = {
-  none: load.Display.None,
-  flex: load.Display.Flex,
-  contents: load.Display.Contents
+  flex: 0,
+  // Display.Flex
+  none: 1,
+  // Display.None
+  contents: 2
+  // Display.Contents
 };
 const directionMap = {
-  inherit: load.Direction.Inherit,
-  ltr: load.Direction.LTR,
-  rtl: load.Direction.RTL
+  inherit: 0,
+  // Direction.Inherit
+  ltr: 1,
+  // Direction.LTR
+  rtl: 2
+  // Direction.RTL
 };
 const flexDirectionMap = {
-  "column": load.FlexDirection.Column,
-  "column-reverse": load.FlexDirection.ColumnReverse,
-  "row": load.FlexDirection.Row,
-  "row-reverse": load.FlexDirection.RowReverse
+  "column": 0,
+  // FlexDirection.Column
+  "column-reverse": 1,
+  // FlexDirection.ColumnReverse
+  "row": 2,
+  // FlexDirection.Row
+  "row-reverse": 3
+  // FlexDirection.RowReverse
 };
 const flexWrapMap = {
-  "no-wrap": load.Wrap.NoWrap,
-  "wrap": load.Wrap.Wrap,
-  "Wrap-reverse": load.Wrap.WrapReverse
+  "no-wrap": 0,
+  // Wrap.NoWrap
+  "wrap": 1,
+  // Wrap.Wrap
+  "Wrap-reverse": 2
+  // Wrap.WrapReverse
 };
 const justifyMap = {
-  "flex-start": load.Justify.FlexStart,
-  "center": load.Justify.Center,
-  "flex-end": load.Justify.FlexEnd,
-  "space-between": load.Justify.SpaceBetween,
-  "space-around": load.Justify.SpaceAround,
-  "space-evenly": load.Justify.SpaceEvenly
+  "flex-start": 0,
+  // Justify.FlexStart
+  "center": 1,
+  // Justify.Center
+  "flex-end": 2,
+  // Justify.FlexEnd
+  "space-between": 3,
+  // Justify.SpaceBetween
+  "space-around": 4,
+  // Justify.SpaceAround
+  "space-evenly": 5
+  // Justify.SpaceEvenly
 };
 const overflowMap = {
-  visible: load.Overflow.Visible,
-  hidden: load.Overflow.Hidden,
-  scroll: load.Overflow.Scroll
+  visible: 0,
+  // Overflow.Visible
+  hidden: 1,
+  // Overflow.Hidden
+  scroll: 2
+  // Overflow.Scroll
 };
 const positionTypeMap = {
-  static: load.PositionType.Static,
-  relative: load.PositionType.Relative,
-  absolute: load.PositionType.Absolute
+  static: 0,
+  // PositionType.Static
+  relative: 1,
+  // PositionType.Relative
+  absolute: 2
+  // PositionType.Absolute
 };
 const boxSizingMap = {
-  "border-box": load.BoxSizing.BorderBox,
-  "content-box": load.BoxSizing.ContentBox
+  "border-box": 0,
+  // BoxSizing.BorderBox
+  "content-box": 1
+  // BoxSizing.ContentBox
 };
 class FlexLayout {
   constructor(_element) {
@@ -10405,7 +10482,8 @@ class FlexLayout {
   }
   static _yoga;
   static async load() {
-    this._yoga = await load.loadYoga();
+    const { loadYoga } = await import('yoga-layout/load');
+    this._yoga = await loadYoga();
   }
   _node = FlexLayout._yoga.Node.create();
   get _style() {
@@ -10451,19 +10529,19 @@ class FlexLayout {
         this._node.setAspectRatio(value);
         break;
       case "borderTop":
-        this._node.setBorder(load.Edge.Top, this._style.borderWidth);
+        this._node.setBorder(edgeMap.top, this._style.borderWidth);
         break;
       case "borderBottom":
-        this._node.setBorder(load.Edge.Bottom, this._style.borderWidth);
+        this._node.setBorder(edgeMap.bottom, this._style.borderWidth);
         break;
       case "borderLeft":
-        this._node.setBorder(load.Edge.Left, this._style.borderWidth);
+        this._node.setBorder(edgeMap.left, this._style.borderWidth);
         break;
       case "borderRight":
-        this._node.setBorder(load.Edge.Right, this._style.borderWidth);
+        this._node.setBorder(edgeMap.right, this._style.borderWidth);
         break;
       case "border":
-        this._node.setBorder(load.Edge.All, this._style.borderWidth);
+        this._node.setBorder(edgeMap.all, this._style.borderWidth);
         break;
       case "direction":
         this._node.setDirection(
@@ -10506,22 +10584,22 @@ class FlexLayout {
         );
         break;
       case "gap":
-        value !== void 0 && this._node.setGap(load.Gutter.All, value);
+        value !== void 0 && this._node.setGap(gutterMap.all, value);
         break;
       case "marginTop":
-        this._node.setMargin(load.Edge.Top, value);
+        this._node.setMargin(edgeMap.top, value);
         break;
       case "marginBottom":
-        this._node.setMargin(load.Edge.Top, value);
+        this._node.setMargin(edgeMap.bottom, value);
         break;
       case "marginLeft":
-        this._node.setMargin(load.Edge.Left, value);
+        this._node.setMargin(edgeMap.left, value);
         break;
       case "marginRight":
-        this._node.setMargin(load.Edge.Top, value);
+        this._node.setMargin(edgeMap.right, value);
         break;
       case "margin":
-        this._node.setMargin(load.Edge.All, value);
+        this._node.setMargin(edgeMap.all, value);
         break;
       case "maxHeight":
         this._node.setMaxHeight(value);
@@ -10543,31 +10621,31 @@ class FlexLayout {
         );
         break;
       case "paddingTop":
-        this._node.setPadding(load.Edge.Top, this._style.paddingTop);
+        this._node.setPadding(edgeMap.top, this._style.paddingTop);
         break;
       case "paddingBottom":
-        this._node.setPadding(load.Edge.Bottom, this._style.paddingBottom);
+        this._node.setPadding(edgeMap.bottom, this._style.paddingBottom);
         break;
       case "paddingLeft":
-        this._node.setPadding(load.Edge.Left, this._style.paddingLeft);
+        this._node.setPadding(edgeMap.left, this._style.paddingLeft);
         break;
       case "paddingRight":
-        this._node.setPadding(load.Edge.Right, this._style.paddingRight);
+        this._node.setPadding(edgeMap.right, this._style.paddingRight);
         break;
       case "padding":
-        this._node.setPadding(load.Edge.All, this._style.padding);
+        this._node.setPadding(edgeMap.all, this._style.padding);
         break;
       case "top":
-        this._node.setPosition(load.Edge.Top, this._style.top);
+        this._node.setPosition(edgeMap.top, this._style.top);
         break;
       case "bottom":
-        this._node.setPosition(load.Edge.Bottom, this._style.bottom);
+        this._node.setPosition(edgeMap.bottom, this._style.bottom);
         break;
       case "left":
-        this._node.setPosition(load.Edge.Left, this._style.left);
+        this._node.setPosition(edgeMap.left, this._style.left);
         break;
       case "right":
-        this._node.setPosition(load.Edge.Right, this._style.right);
+        this._node.setPosition(edgeMap.right, this._style.right);
         break;
       case "position":
         this._node.setPositionType(
@@ -10648,7 +10726,7 @@ exports.FlexElement2D = class FlexElement2D extends exports.BaseElement2D {
     }
   }
   updateTransform() {
-    this.calculateLayout(void 0, void 0, load.Direction.LTR);
+    this.calculateLayout(void 0, void 0, directionMap.ltr);
     const { left, top, width, height } = this._layout.getComputedLayout();
     this.position.x = left;
     this.position.y = top;
@@ -13431,7 +13509,7 @@ exports.TwistTransition = __decorateClass$1([
   customNode("TwistTransition")
 ], exports.TwistTransition);
 
-class GIFLoader extends Loader {
+class GifLoader extends Loader {
   install(assets) {
     const handler = async (url) => {
       const { decodeFrames } = await import('modern-gif');
@@ -13457,7 +13535,7 @@ class GIFLoader extends Loader {
   }
 }
 
-class JSONLoader extends Loader {
+class JsonLoader extends Loader {
   install(assets) {
     const handler = (url) => {
       return assets.fetch(url).then((rep) => rep.json());
@@ -13789,7 +13867,7 @@ class Assets {
     this._handled.clear();
   }
 }
-const assets = new Assets().use(new FontLoader()).use(new GIFLoader()).use(new JSONLoader()).use(new LottieLoader()).use(new TextLoader()).use(new TextureLoader()).use(new VideoLoader());
+const assets = new Assets().use(new FontLoader()).use(new GifLoader()).use(new JsonLoader()).use(new LottieLoader()).use(new TextLoader()).use(new TextureLoader()).use(new VideoLoader());
 
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -14261,8 +14339,8 @@ exports.Engine = Engine;
 exports.FlexElement2DStyle = FlexElement2DStyle;
 exports.FlexLayout = FlexLayout;
 exports.FontLoader = FontLoader;
-exports.GIFLoader = GIFLoader;
 exports.Geometry = Geometry;
+exports.GifLoader = GifLoader;
 exports.GradientTexture = GradientTexture;
 exports.HTMLAudio = HTMLAudio;
 exports.HTMLAudioContext = HTMLAudioContext;
@@ -14272,7 +14350,7 @@ exports.ImageTexture = ImageTexture;
 exports.IndexBuffer = IndexBuffer;
 exports.Input = Input;
 exports.InputEvent = InputEvent;
-exports.JSONLoader = JSONLoader;
+exports.JsonLoader = JsonLoader;
 exports.KeyboardInputEvent = KeyboardInputEvent;
 exports.Loader = Loader;
 exports.LottieLoader = LottieLoader;
@@ -14348,7 +14426,9 @@ exports.WebGLVertexArrayModule = WebGLVertexArrayModule;
 exports.WebGLViewportModule = WebGLViewportModule;
 exports.WebSound = WebSound;
 exports.WheelInputEvent = WheelInputEvent;
+exports.alignMap = alignMap;
 exports.assets = assets;
+exports.boxSizingMap = boxSizingMap;
 exports.clamp = clamp;
 exports.clampFrag = clampFrag;
 exports.createHTMLCanvas = createHTMLCanvas;
@@ -14360,29 +14440,38 @@ exports.customNode = customNode;
 exports.customNodes = customNodes;
 exports.defaultOptions = defaultOptions;
 exports.determineCrossOrigin = determineCrossOrigin;
+exports.directionMap = directionMap;
+exports.displayMap = displayMap;
 exports.ease = ease;
 exports.easeIn = easeIn;
 exports.easeInOut = easeInOut;
 exports.easeOut = easeOut;
+exports.edgeMap = edgeMap;
+exports.flexDirectionMap = flexDirectionMap;
+exports.flexWrapMap = flexWrapMap;
 exports.frag = frag$1;
 exports.getDefaultCssPropertyValue = getDefaultCssPropertyValue;
+exports.gutterMap = gutterMap;
 exports.isCanvasElement = isCanvasElement;
 exports.isElementNode = isElementNode;
 exports.isImageElement = isImageElement;
 exports.isPow2 = isPow2;
 exports.isVideoElement = isVideoElement;
 exports.isWebgl2 = isWebgl2;
+exports.justifyMap = justifyMap;
 exports.lerp = lerp;
 exports.linear = linear;
 exports.log2 = log2;
 exports.mapWebGLBlendModes = mapWebGLBlendModes;
 exports.nextPow2 = nextPow2;
 exports.nextTick = nextTick;
+exports.overflowMap = overflowMap;
 exports.parseCSSFilter = parseCSSFilter;
 exports.parseCSSTransform = parseCSSTransform;
 exports.parseCSSTransformOrigin = parseCSSTransformOrigin;
 exports.parseCssFunctions = parseCssFunctions;
 exports.parseCssProperty = parseCssProperty;
+exports.positionTypeMap = positionTypeMap;
 exports.render = render;
 exports.timingFunctions = timingFunctions;
 exports.uid = uid;