@js-draw/math 1.0.0 → 1.0.2

package/src/shapes/Path.fromString.test.ts

@@ -0,0 +1,223 @@
+// Tests to ensure that Paths can be deserialized
+
+import Path, { PathCommandType } from './Path';
+import { Vec2 } from '../Vec2';
+
+describe('Path.fromString', () => {
+	it('should handle an empty path', () => {
+		const path = Path.fromString('');
+		expect(path.geometry.length).toBe(0);
+	});
+
+	it('should properly handle absolute moveTo commands', () => {
+		const path1 = Path.fromString('M0,0');
+		const path2 = Path.fromString('M 0 0');
+		const path3 = Path.fromString('M 1,1M 2,2 M 3,3');
+
+		expect(path1.parts.length).toBe(0);
+		expect(path1.startPoint).toMatchObject(Vec2.zero);
+
+		expect(path2.parts.length).toBe(0);
+		expect(path2.startPoint).toMatchObject(Vec2.zero);
+
+		expect(path3.parts).toMatchObject([
+			{
+				kind: PathCommandType.MoveTo,
+				point: Vec2.of(2, 2),
+			},
+			{
+				kind: PathCommandType.MoveTo,
+				point: Vec2.of(3,3),
+			},
+		]);
+		expect(path3.startPoint).toMatchObject(Vec2.of(1, 1));
+	});
+
+	it('should properly handle relative moveTo commands', () => {
+		const path = Path.fromString('m1,1  	m0,0 m   3,3');
+		expect(path.parts).toMatchObject([
+			{
+				kind: PathCommandType.MoveTo,
+				point: Vec2.of(1, 1),
+			},
+			{
+				kind: PathCommandType.MoveTo,
+				point: Vec2.of(4, 4),
+			},
+		]);
+		expect(path.startPoint).toMatchObject(Vec2.of(1, 1));
+	});
+
+	it('should handle lineTo commands', () => {
+		const path = Path.fromString('l1,2L-1,0l0.1,-1.0');
+		// l is a relative lineTo, but because there
+		// is no previous command, it should act like an
+		// absolute moveTo.
+		expect(path.startPoint).toMatchObject(Vec2.of(1, 2));
+
+		expect(path.parts).toMatchObject([
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-1, 0),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-0.9, -1.0),
+			},
+		]);
+	});
+
+	it('"z" should close strokes', () => {
+		const path1 = Path.fromString('m3,3 l1,2 l1,1 z');
+		const path2 = Path.fromString('m3,3 l1,2 l1,1 Z');
+
+		expect(path1.startPoint).toMatchObject(Vec2.of(3,3));
+		expect(path2.startPoint).toMatchObject(path1.startPoint);
+		expect(path1.parts).toMatchObject(path2.parts);
+		expect(path1.parts).toMatchObject([
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(4, 5),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(5, 6),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: path1.startPoint,
+			}
+		]);
+	});
+
+	it('should break compoents at -s', () => {
+		const path = Path.fromString('m1-1 L-1-1-3-4-5-6,5-1');
+		expect(path.parts.length).toBe(4);
+		expect(path.parts).toMatchObject([
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-1, -1),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-3, -4),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-5, -6),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(5, -1),
+			},
+		]);
+	});
+
+	it('should properly handle cubic Bézier curves', () => {
+		const path = Path.fromString('m1,1 c1,1 0-3 4 5 C1,1 0.1, 0.1 0, 0');
+		expect(path.parts.length).toBe(2);
+		expect(path.parts).toMatchObject([
+			{
+				kind: PathCommandType.CubicBezierTo,
+				controlPoint1: Vec2.of(2, 2),
+				controlPoint2: Vec2.of(1, -2),
+				endPoint: Vec2.of(5, 6),
+			},
+			{
+				kind: PathCommandType.CubicBezierTo,
+				controlPoint1: Vec2.of(1, 1),
+				controlPoint2: Vec2.of(0.1, 0.1),
+				endPoint: Vec2.zero,
+			}
+		]);
+	});
+
+	it('should handle quadratic Bézier curves', () => {
+		const path = Path.fromString(' Q1 1,2 3 q-1 -2,-3 -4 Q 1 2,3 4');
+		expect(path.parts).toMatchObject([
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(1, 1),
+				endPoint: Vec2.of(2, 3),
+			},
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(1, 1),
+				endPoint: Vec2.of(-1, -1),
+			},
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(1, 2),
+				endPoint: Vec2.of(3, 4),
+			},
+		]);
+		expect(path.startPoint).toMatchObject(Vec2.of(1, 1));
+	});
+
+	it('should correctly handle a command followed by multiple sets of arguments', () => {
+		// Commands followed by multiple sets of arguments, for example,
+		//  l 5,10 5,4 3,2,
+		// should be interpreted as multiple commands. Our example, is therefore equivalent to,
+		//  l 5,10 l 5,4 l 3,2
+
+		const path = Path.fromString(`
+			L5,10 1,1
+			 2,2 -3,-1
+			q 1,2 1,1
+			  -1,-1 -3,-4
+			h -4 -1
+			V 3 5 1
+		`);
+		expect(path.parts).toMatchObject([
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(1, 1),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(2, 2),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-3, -1),
+			},
+
+			// q 1,2 1,1    -1,-1 -3,-4
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(-2, 1),
+				endPoint: Vec2.of(-2, 0),
+			},
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(-3, -1),
+				endPoint: Vec2.of(-5, -4),
+			},
+
+			// h -4 -1
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-9, -4),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-10, -4),
+			},
+
+			// V 3 5 1
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-10, 3),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-10, 5),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(-10, 1),
+			},
+		]);
+		expect(path.startPoint).toMatchObject(Vec2.of(5, 10));
+	});
+});

package/src/shapes/Path.test.ts

@@ -0,0 +1,309 @@
+import LineSegment2 from './LineSegment2';
+import Path, { PathCommandType } from './Path';
+import Rect2 from './Rect2';
+import { Vec2 } from '../Vec2';
+import CubicBezier from './CubicBezier';
+import QuadraticBezier from './QuadraticBezier';
+
+describe('Path', () => {
+	it('should instantiate Beziers from cubic and quatratic commands', () => {
+		const path = new Path(Vec2.zero, [
+			{
+				kind: PathCommandType.CubicBezierTo,
+				controlPoint1: Vec2.of(1, 1),
+				controlPoint2: Vec2.of(-1, -1),
+				endPoint: Vec2.of(3, 3),
+			},
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(1, 1),
+				endPoint: Vec2.of(0, 0),
+			},
+		]);
+
+		expect(path.geometry.length).toBe(2);
+
+		const firstItem = path.geometry[0];
+		const secondItem = path.geometry[1];
+		expect(firstItem).toBeInstanceOf(CubicBezier);
+		expect(secondItem).toBeInstanceOf(QuadraticBezier);
+
+		// Force TypeScript to do type narrowing.
+		if (!(firstItem instanceof CubicBezier) || !(secondItem instanceof QuadraticBezier)) {
+			throw new Error('Invalid state! .toBeInstanceOf should have caused test to fail!');
+		}
+
+		// Make sure the control points (and start/end points) match what was set
+		expect(firstItem.getPoints()).toMatchObject([
+			{ x: 0, y: 0 }, { x: 1, y: 1 }, { x: -1, y: -1 }, { x: 3, y: 3 }
+		]);
+		expect(secondItem.getPoints()).toMatchObject([
+			{ x: 3, y: 3 }, { x: 1, y: 1 }, { x: 0, y: 0 },
+		]);
+	});
+
+	it('should create LineSegments from line commands', () => {
+		const lineStart = Vec2.zero;
+		const lineEnd = Vec2.of(100, 100);
+
+		const path = new Path(lineStart, [
+			{
+				kind: PathCommandType.LineTo,
+				point: lineEnd,
+			},
+		]);
+
+		expect(path.geometry.length).toBe(1);
+		expect(path.geometry[0]).toBeInstanceOf(LineSegment2);
+		expect(path.geometry[0]).toMatchObject(
+			new LineSegment2(lineStart, lineEnd)
+		);
+	});
+
+	describe('intersection', () => {
+		it('should give all intersections for a path made up of lines', () => {
+			const lineStart = Vec2.of(100, 100);
+			const path = new Path(lineStart, [
+				{
+					kind: PathCommandType.LineTo,
+					point: Vec2.of(-100, 100),
+				},
+				{
+					kind: PathCommandType.LineTo,
+					point: Vec2.of(0, 0),
+				},
+				{
+					kind: PathCommandType.LineTo,
+					point: Vec2.of(100, -100),
+				},
+			]);
+
+			const intersections = path.intersection(
+				new LineSegment2(Vec2.of(-50, 200), Vec2.of(-50, -200))
+			);
+
+			// Should only have intersections in quadrants II and III.
+			expect(intersections.length).toBe(2);
+
+			// First intersection should be with the first curve
+			const firstIntersection = intersections[0];
+			expect(firstIntersection.point.xy).toMatchObject({
+				x: -50,
+				y: 100,
+			});
+		});
+
+		it('should give all intersections for a stroked path', () => {
+			const lineStart = Vec2.of(100, 100);
+
+			// Create a path in this shape:
+			// + - - - -|- - - - +
+			//  \       |
+			//    \     |
+			//      \   |
+			//        \ |
+			// ---------------------
+			//          | \
+			//          |   \
+			//          |     \
+			//          |       \
+			//          |         +
+			const path = new Path(lineStart, [
+				{
+					kind: PathCommandType.LineTo,
+					point: Vec2.of(-100, 100),
+				},
+				{
+					kind: PathCommandType.LineTo,
+					point: Vec2.of(0, 0),
+				},
+				{
+					kind: PathCommandType.LineTo,
+					point: Vec2.of(100, -100),
+				},
+			]);
+
+			const strokeWidth = 5;
+			let intersections = path.intersection(
+				new LineSegment2(Vec2.of(2000, 200), Vec2.of(2000, 400)), strokeWidth,
+			);
+			expect(intersections.length).toBe(0);
+
+			// Test a line that only enters, but does not exit one of the strokes:
+			//
+			//        * <- Line to test
+			//        |
+			//   _____|_____________
+			//        |
+			//        *       Stroke
+			//
+			//   ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+
+			intersections = path.intersection(
+				new LineSegment2(Vec2.of(-50, 200), Vec2.of(-50, 100)), strokeWidth,
+			);
+			expect(intersections.length).toBe(1);
+			expect(intersections[0].point.xy).toMatchObject({
+				x: -50,
+				y: 105,
+			});
+
+
+			// Changing the order of the end points on the line should not change the result
+			intersections = path.intersection(
+				new LineSegment2(Vec2.of(-50, 100), Vec2.of(-50, 200)), strokeWidth,
+			);
+			expect(intersections.length).toBe(1);
+			expect(intersections[0].point.xy).toMatchObject({
+				x: -50,
+				y: 105,
+			});
+
+			// This line should intersect two of the strokes. Thus, there should be four
+			// intersections — one entering and one leaving for each intersection with the
+			// centers.
+			intersections = path.intersection(
+				new LineSegment2(Vec2.of(-50, 200), Vec2.of(-50, -200)), strokeWidth,
+			);
+			expect(intersections.length).toBe(4);
+
+			// Intersections should be in increasing order away from the
+			// first point on the line.
+			expect(intersections[0].point.xy).toMatchObject({
+				x: -50,
+				y: 105,
+			});
+			expect(intersections[1].point.xy).toMatchObject({
+				x: -50,
+				y: 95,
+			});
+		});
+
+		it('should give all intersections for a Bézier stroked path', () => {
+			const lineStart = Vec2.zero;
+			const path = new Path(lineStart, [
+				{
+					kind: PathCommandType.QuadraticBezierTo,
+					controlPoint: Vec2.unitX,
+					endPoint: Vec2.unitY,
+				}
+			]);
+
+			const strokeWidth = 5;
+
+			// Should be no intersections for a line contained entirely within the stroke
+			// (including stroke width).
+			let intersections = path.intersection(
+				new LineSegment2(Vec2.of(-1, 0.5), Vec2.of(2, 0.5)), strokeWidth,
+			);
+			expect(intersections.length).toBe(0);
+
+			// Should be an intersection when exiting/entering the edge of the stroke
+			intersections = path.intersection(
+				new LineSegment2(Vec2.of(0, 0.5), Vec2.of(8, 0.5)), strokeWidth,
+			);
+			expect(intersections.length).toBe(1);
+		});
+	});
+
+	describe('polylineApproximation', () => {
+		it('should approximate Bézier curves with polylines', () => {
+			const path = Path.fromString('m0,0 l4,4 Q 1,4 4,1z');
+
+			expect(path.polylineApproximation()).toMatchObject([
+				new LineSegment2(Vec2.of(0, 0), Vec2.of(4, 4)),
+				new LineSegment2(Vec2.of(4, 4), Vec2.of(1, 4)),
+				new LineSegment2(Vec2.of(1, 4), Vec2.of(4, 1)),
+				new LineSegment2(Vec2.of(4, 1), Vec2.of(0, 0)),
+			]);
+		});
+	});
+
+	describe('roughlyIntersectsClosed', () => {
+		it('small, line-only path', () => {
+			const path = Path.fromString('m0,0 l10,10 L0,10 z');
+			expect(
+				path.closedRoughlyIntersects(Rect2.fromCorners(Vec2.zero, Vec2.of(20, 20)))
+			).toBe(true);
+			expect(
+				path.closedRoughlyIntersects(Rect2.fromCorners(Vec2.zero, Vec2.of(2, 2)))
+			).toBe(true);
+			expect(
+				path.closedRoughlyIntersects(new Rect2(10, 1, 1, 1))
+			).toBe(false);
+			expect(
+				path.closedRoughlyIntersects(new Rect2(1, 5, 1, 1))
+			).toBe(true);
+		});
+
+		it('path with Bézier curves', () => {
+			const path = Path.fromString(`
+				M1090,2560
+				L1570,2620
+				Q1710,1300 1380,720
+				Q980,100 -460,-640
+				L-680,-200
+				Q670,470 960,980
+				Q1230,1370 1090,2560
+			`);
+			expect(
+				path.closedRoughlyIntersects(new Rect2(0, 0, 500, 500))
+			).toBe(true);
+			expect(
+				path.closedRoughlyIntersects(new Rect2(0, 0, 5, 5))
+			).toBe(true);
+			expect(
+				path.closedRoughlyIntersects(new Rect2(-10000, 0, 500, 500))
+			).toBe(false);
+		});
+	});
+
+	describe('roughlyIntersects', () => {
+		it('should consider parts outside bbox of individual parts of a line as not intersecting', () => {
+			const path = Path.fromString(`
+				M10,10
+				L20,20
+				L100,21
+			`);
+			expect(
+				path.roughlyIntersects(new Rect2(0, 0, 50, 50))
+			).toBe(true);
+			expect(
+				path.roughlyIntersects(new Rect2(0, 0, 5, 5))
+			).toBe(false);
+			expect(
+				path.roughlyIntersects(new Rect2(8, 22, 1, 1))
+			).toBe(false);
+			expect(
+				path.roughlyIntersects(new Rect2(21, 11, 1, 1))
+			).toBe(false);
+			expect(
+				path.roughlyIntersects(new Rect2(50, 19, 1, 2))
+			).toBe(true);
+		});
+	});
+
+	describe('fromRect', () => {
+		const filledRect = Path.fromRect(Rect2.unitSquare);
+		const strokedRect = Path.fromRect(Rect2.unitSquare, 0.1);
+
+		it('filled should be closed shape', () => {
+			const lastSegment = filledRect.parts[filledRect.parts.length - 1];
+
+			if (lastSegment.kind !== PathCommandType.LineTo) {
+				throw new Error('Rectangles should only be made up of lines');
+			}
+
+			expect(filledRect.startPoint).objEq(lastSegment.point);
+		});
+
+		it('stroked should be closed shape', () => {
+			const lastSegment = strokedRect.parts[strokedRect.parts.length - 1];
+			if (lastSegment.kind !== PathCommandType.LineTo) {
+				throw new Error('Rectangles should only be made up of lines');
+			}
+
+			expect(strokedRect.startPoint).objEq(lastSegment.point);
+		});
+	});
+});

package/src/shapes/Path.toString.test.ts

@@ -0,0 +1,77 @@
+import Path, { PathCommandType } from './Path';
+import { Vec2 } from '../Vec2';
+
+
+describe('Path.toString', () => {
+	it('a single-point path should produce a move-to command', () => {
+		const path = new Path(Vec2.of(0, 0), []);
+		expect(path.toString()).toBe('M0,0');
+	});
+
+	it('should convert lineTo commands to L SVG commands', () => {
+		const path = new Path(Vec2.of(0.1, 0.2), [
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(0.3, 0.4),
+			},
+		]);
+		expect(path.toString()).toBe('M.1,.2L.3,.4');
+	});
+
+	it('should fix rounding errors', () => {
+		const path = new Path(Vec2.of(0.100000001, 0.199999999), [
+			{
+				kind: PathCommandType.QuadraticBezierTo,
+				controlPoint: Vec2.of(9999, -10.999999995),
+				endPoint: Vec2.of(0.000300001, 1.400000002),
+			},
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(184.00482359999998, 1)
+			}
+		]);
+
+		expect(path.toString()).toBe('M.1,.2Q9999,-11 .0003,1.4L184.0048236,1');
+	});
+
+	it('should not remove trailing zeroes before decimal points', () => {
+		const path = new Path(Vec2.of(1000, 2_000_000), [
+			{
+				kind: PathCommandType.LineTo,
+				point: Vec2.of(30.00000001, 40.000000001),
+			},
+		]);
+
+		expect(path.toString()).toBe('M1000,2000000l-970-1999960');
+	});
+
+	it('deserialized path should serialize to the same/similar path, but with rounded components', () => {
+		const path1 = Path.fromString('M100,100 L101,101 Q102,102 90.000000001,89.99999999 Z');
+		path1['cachedStringVersion'] = null; // Clear the cache.
+
+		expect(path1.toString()).toBe([
+			'M100,100', 'l1,1', 'q1,1 -11-11', 'l10,10'
+		].join(''));
+	});
+
+	it('should not lose precision when saving', () => {
+		const pathStr = 'M184.2,52.3l-.2-.2q-2.7,2.4 -3.2,3.5q-2.8,7 -.9,6.1q4.3-2.6 4.8-6.1q1.2-8.8 .4-8.3q-4.2,5.2 -3.9,3.9q.2-1.6 .3-2.1q.2-1.3 -.2-1q-3.8,6.5 -3.2,3.3q.6-4.1 1.1-5.3q4.1-10 3.3-8.3q-5.3,13.1 -6.6,14.1q-3.3,2.8 -1.8-1.5q2.8-9.7 2.7-8.4q0,.3 0,.4q-1.4,7.1 -2.7,8.5q-2.6,3.2 -2.5,2.9q-.3-1.9 -.7-1.9q-4.1,4.4 -2.9,1.9q1.1-3 .3-2.6q-1.8,2 -2.5,2.4q-4.5,2.8 -4.2,1.9q.3-1.6 .2-1.4q1.5,2.2 1.3,2.9q-.8,3.9 -.5,3.3q.8-7.6 2.5-13.3q2.6-9.2 2.9-6.9q.3,1.4 .3,1.2q-.7-.4 -.9,0q-2.2,11.6 -7.6,13.6q-3.9,1.6 -2.1-1.3q3-5.5 2.6-3.4q-.2,1.8 -.5,1.8q-3.2,.5 -4.1,1.2q-2.6,2.6 -1.9,2.5q4.7-4.4 3.7-5.5q-1.1-.9 -1.6-.6q-7.2,7.5 -3.9,6.5q.3-.1 .4-.4q.6-5.3 -.2-4.9q-2.8,2.3 -3.1,2.4q-3.7,1.5 -3.5,.5q.3-3.6 1.4-3.3q3.5,.7 1.9,2.4q-1.7,2.3 -1.6,.8q0-3.5 -.9-3.1q-5.1,3.3 -4.9,2.8q.1-4 -.8-3.5q-4.3,3.4 -4.6,2.5q-1-2.1 .5-8.7l-.2,0q-1.6,6.6 -.7,8.9q.7,1.2 5.2-2.3q.4-.5 .2,3.1q.1,1 5.5-2.4q.4-.4 .3,2.7q.1,2 2.4-.4q1.7-2.3 -2.1-3.2q-1.7-.3 -2,3.7q0,1.4 4.1-.1q.3-.1 3.1-2.4q.3-.5 -.4,4.5q0-.1 -.2,0q-2.6,1.2 4.5-5.7q0-.2 .8,.6q.9,.6 -3.7,4.7q-.5,1 2.7-1.7q.6-.7 3.7-1.2q.7-.2 .9-2.2q.1-2.7 -3.4,3.2q-1.8,3.4 2.7,1.9q5.6-2.1 7.8-14q-.1,.1 .3,.4q.6,.1 .3-1.6q-.7-2.8 -3.7,6.7q-1.8,5.8 -2.5,13.5q.1,1.1 1.3-3.1q.2-1 -1.3-3.3q-.5-.5 -1,1.6q-.1,1.3 4.8-1.5q1-1 3-2q.1-.4 -1.1,2q-1.1,3.1 3.7-1.3q-.4,0 -.1,1.5q.3,.8 3.3-2.5q1.3-1.6 2.7-8.9q0-.1 0-.4q-.3-1.9 -3.5,8.2q-1.3,4.9 2.4,2.1q1.4-1.2 6.6-14.3q.8-2.4 -3.9,7.9q-.6,1.3 -1.1,5.5q-.3,3.7 4-3.1q-.2,0 -.6,.6q-.2,.6 -.3,2.3q0,1.8 4.7-3.5q.1-.5 -1.2,7.9q-.5,3.2 -4.6,5.7q-1.3,1 1.5-5.5q.4-1.1 3.01-3.5';
+
+		const path1 = Path.fromString(pathStr);
+		path1['cachedStringVersion'] = null; // Clear the cache.
+		const path = Path.fromString(path1.toString(true));
+		path1['cachedStringVersion'] = null; // Clear the cache.
+
+		expect(path.toString(true)).toBe(path1.toString(true));
+	});
+
+	it('should remove no-op move-tos', () => {
+		const path1 = Path.fromString('M50,75m0,0q0,12.5 0,50q0,6.3 25,0');
+		path1['cachedStringVersion'] = null;
+		const path2 = Path.fromString('M150,175M150,175q0,12.5 0,50q0,6.3 25,0');
+		path2['cachedStringVersion'] = null;
+
+		expect(path1.toString()).toBe('M50,75q0,12.5 0,50q0,6.3 25,0');
+		expect(path2.toString()).toBe('M150,175q0,12.5 0,50q0,6.3 25,0');
+	});
+});