diff --git a/pom.xml b/pom.xml
index cb7c528..59a6519 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,7 +5,7 @@
     License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
     WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
   -->
-<project xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd' xmlns='http://maven.apache.org/POM/4.0.0'>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
@@ -15,15 +15,15 @@
   </parent>
 
   <artifactId>maven-common-artifact-filters</artifactId>
-  <version>1.3-SNAPSHOT</version>
+  <version>1.3</version>
 
   <name>Maven Common Artifact Filters</name>
   <description>A collection of ready-made filters to control inclusion/exclusion of artifacts during dependency resolution.</description>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/shared/trunk/maven-common-artifact-filters</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/shared/trunk/maven-common-artifact-filters</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/shared/trunk/maven-common-artifact-filters</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/shared/tags/maven-common-artifact-filters-1.3</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/shared/tags/maven-common-artifact-filters-1.3</developerConnection>
+    <url>http://svn.apache.org/viewvc/maven/shared/tags/maven-common-artifact-filters-1.3</url>
   </scm>
   <issueManagement>
     <system>jira</system>
