mailwoman 0.2.0

package/eslint.config.mjs

@@ -0,0 +1,32 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+import { createESLintPackageConfig } from "@sister.software/eslint-config"
+import html from "eslint-plugin-html"
+
+// @ts-check
+
+/**
+ * ESLint configuration for the Mailwoman repo
+ */
+const MailwomanESLintConfig = createESLintPackageConfig({
+	copyrightHolder: "OpenISP, Inc.",
+	packageTitle: "Mailwoman",
+	spdxLicenseIdentifier: "AGPL-3.0",
+
+	overrides: {
+		plugins: { html },
+		rules: {
+			"@typescript-eslint/no-require-imports": "off",
+			"no-prototype-builtins": "off",
+			"jsdoc/require-property-description": "off",
+			"jsdoc/require-returns-description": "off",
+			"jsdoc/require-param-description": "off",
+		},
+	},
+})
+
+export default MailwomanESLintConfig

package/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+export * from "./debug/DebugOutputBuilder.js"
+export * from "./parser/index.js"
+export { default as Solution } from "./solver/Solution.js"
+export * from "./tokenization/Tokenizer.js"

package/out/bin/cli.js

@@ -0,0 +1,41 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+import { DebugOutputBuilder, parseAddressInput } from "mailwoman";
+/**
+ * Initialize the CLI and parse the input command.
+ */
+async function initCLI() {
+    const args = process.argv.slice(2);
+    const commandName = args[0];
+    if (!commandName || commandName === "--help" || commandName === "-h" || commandName === "help") {
+        console.log("mailwoman [command] [address]");
+        console.log("Commands:");
+        console.log("\tparse: Parse an address in JSON format");
+        console.log("\tdebug: Parse an address and output debug information");
+        console.log("\tserve: Start the parser server");
+        return;
+    }
+    if (commandName === "serve") {
+        console.log("Starting the parser server...");
+        const { startPeliasParserServer } = await import("mailwoman/server");
+        const app = startPeliasParserServer();
+        return new Promise((resolve) => {
+            app.addListener("close", resolve);
+        });
+    }
+    if (commandName === "debug") {
+        const builder = new DebugOutputBuilder();
+        const formattedAddress = args.slice(1).join(" ");
+        builder.parse(formattedAddress);
+        console.log(builder.toString());
+        return;
+    }
+    const formattedAddress = commandName === "parse" ? args.slice(1).join(" ") : args.join(" ");
+    const results = parseAddressInput(formattedAddress);
+    console.log(JSON.stringify(results, null, 2));
+}
+export default initCLI();
+//# sourceMappingURL=cli.js.map

package/package.json

@@ -0,0 +1,130 @@
+{
+  "name": "mailwoman",
+  "version": "0.2.0",
+  "description": "Utilities for working with contacts for email, phone, and postal addresses.",
+  "keywords": [
+    "pelias"
+  ],
+  "homepage": "https://github.com/isp-nexus/mailwoman",
+  "bugs": {
+    "url": "https://github.com/pelias/parser/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pelias/parser.git"
+  },
+  "license": "AGPL-3.0-only",
+  "contributors": [
+    {
+      "name": "Teffen Ellis",
+      "email": "teffen@sister.software"
+    },
+    {
+      "name": "Pelias Contributors"
+    }
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./out/index.js"
+    },
+    "./classifier/super": {
+      "import": "./out/classifier/super/index.js"
+    },
+    "./classifier": {
+      "import": "./out/classifier/index.js"
+    },
+    "./classification": {
+      "import": "./out/classification/index.js"
+    },
+    "./server": {
+      "import": "./out/server/index.js"
+    },
+    "./sdk/test/utils": {
+      "import": "./out/sdk/test/utils/index.js"
+    },
+    "./sdk/repo": {
+      "import": "./out/sdk/repo.js"
+    },
+    "./*": {
+      "import": "./out/*"
+    }
+  },
+  "bin": "./out/bin/cli.js",
+  "scripts": {
+    "demo": "mailwoman parse '3551 W. Hillsboro Blvd Deerfield Beach, FL 33442'",
+    "compile": "NODE_OPTIONS=\"--max-old-space-size=3000\" tsc -b",
+    "compile:clean": "node ./sdk/out/scripts/clean.js",
+    "test:unit": "tape ./out/**/*.test.js --ignore ./out/test/functional/**/*.test.js | npx faucet",
+    "test:functional": "tape ./out/test/functional/*.test.js | npx faucet",
+    "test:oa": "tape ./out/openaddresses.js | npx faucet",
+    "test": "tape ./out/**/*.test.js | npx faucet",
+    "serve": "node ./server/http.js",
+    "ci": "./bin/test",
+    "lint": "run-s lint:prettier:check lint:eslint:check",
+    "lint:fix": "run-s lint:prettier:fix lint:eslint:fix",
+    "lint:prettier:check": "prettier --cache --check -u .",
+    "lint:prettier:fix": "prettier --cache --write -u .",
+    "lint:prettier": "eslint .",
+    "lint:eslint:check": "eslint .",
+    "lint:eslint:fix": "eslint --fix .",
+    "prepare": "husky"
+  },
+  "prettier": "@sister.software/prettier-config",
+  "release": {
+    "branch": "main",
+    "success": []
+  },
+  "dependencies": {
+    "@fragaria/address-formatter": "^6.3.0",
+    "path-ts": "^1.0.5",
+    "pluralize": "^8.0.0",
+    "remove-accents": "^0.5.0"
+  },
+  "devDependencies": {
+    "@sister.software/eslint-config": "7.1.3",
+    "@sister.software/prettier-config": "7.1.3",
+    "@sister.software/tsconfig": "7.1.3",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/deep-eql": "^4.0.2",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.8.1",
+    "@types/pluralize": "^0.0.33",
+    "@types/tape": "^5.6.4",
+    "better-sqlite3": "^11.5.0",
+    "chalk": "^5.3.0",
+    "csv-parse": "^5.5.6",
+    "deep-eql": "^4.0.0",
+    "eslint": "^9.13.0",
+    "eslint-plugin-html": "^8.1.2",
+    "express": "^4.21.1",
+    "fast-glob": "^3.3.2",
+    "faucet": "^0.0.4",
+    "husky": "^9.1.6",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.3.3",
+    "prettier-plugin-jsdoc": "^1.3.0",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "prettier-plugin-packagejson": "^2.5.3",
+    "tape": "^5.9.0",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.11.0"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^11.5.0",
+    "express": "^4.21.1"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
+  },
+  "packageManager": "yarn@4.5.1",
+  "engines": {
+    "node": ">= 10.0.0"
+  }
+}

package/parser/AddressParser.ts

@@ -0,0 +1,162 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+import AlphaNumericClassifier from "../classifier/AlphaNumericClassifier.js"
+import CentralEuropeanStreetNameClassifier from "../classifier/CentralEuropeanStreetNameClassifier.js"
+import ChainClassifier from "../classifier/ChainClassifier.js"
+import CompositeClassifier from "../classifier/CompositeClassifier.js"
+import CompoundStreetClassifier from "../classifier/CompoundStreetClassifier.js"
+import DirectionalClassifier from "../classifier/DirectionalClassifier.js"
+import GivenNameClassifier from "../classifier/GivenNameClassifier.js"
+import HouseNumberClassifier from "../classifier/HouseNumberClassifier.js"
+import IntersectionClassifier from "../classifier/IntersectionClassifier.js"
+import MiddleInitialClassifier from "../classifier/MiddleInitialClassifier.js"
+import OrdinalClassifier from "../classifier/OrdinalClassifier.js"
+import PersonalSuffixClassifier from "../classifier/PersonalSuffixClassifier.js"
+import PersonalTitleClassifier from "../classifier/PersonalTitleClassifier.js"
+import PersonClassifier from "../classifier/PersonClassifier.js"
+import PlaceClassifier from "../classifier/PlaceClassifier.js"
+import PostcodeClassifier from "../classifier/PostcodeClassifier.js"
+import RoadTypeClassifier from "../classifier/RoadTypeClassifier.js"
+import StopWordClassifier from "../classifier/StopWordClassifier.js"
+import StreetPrefixClassifier from "../classifier/StreetPrefixClassifier.js"
+import StreetProperNameClassifier from "../classifier/StreetProperNameClassifier.js"
+import StreetSuffixClassifier from "../classifier/StreetSuffixClassifier.js"
+import SurnameClassifier from "../classifier/SurnameClassifier.js"
+import TokenPositionClassifier from "../classifier/TokenPositionClassifier.js"
+import ToponymClassifier from "../classifier/ToponymClassifier.js"
+import WhosOnFirstClassifier from "../classifier/WhosOnFirstClassifier.js"
+
+import IntersectionScheme from "../classifier/scheme/intersection.js"
+import PersonScheme from "../classifier/scheme/person.js"
+import StreetScheme from "../classifier/scheme/street.js"
+import StreetNameScheme from "../classifier/scheme/street_name.js"
+import VenueScheme from "../classifier/scheme/venue.js"
+
+import ExclusiveCartesianSolver from "../solver/ExclusiveCartesianSolver.js"
+import HouseNumberPositionPenalty from "../solver/HouseNumberPositionPenalty.js"
+import InvalidSolutionFilter from "../solver/InvalidSolutionFilter.js"
+import LeadingAreaDeclassifier from "../solver/LeadingAreaDeclassifier.js"
+import MultiStreetSolver from "../solver/MultiStreetSolver.js"
+import MustNotFollowFilter from "../solver/MustNotFollowFilter.js"
+import MustNotPreceedFilter from "../solver/MustNotPreceedFilter.js"
+import OrphanedUnitTypeDeclassifier from "../solver/OrphanedUnitTypeDeclassifier.js"
+import PostcodePositionPenalty from "../solver/PostcodePositionPenalty.js"
+import SubsetFilter from "../solver/SubsetFilter.js"
+import TokenDistanceFilter from "../solver/TokenDistanceFilter.js"
+
+import { LevelClassifier } from "../classifier/LevelClassifier.js"
+import { LevelTypeClassifier } from "../classifier/LevelTypeClassifier.js"
+import { LevelTypeLevelClassifier } from "../classifier/LevelTypeLevelClassifier.js"
+import { UnitClassifier } from "../classifier/UnitClassifier.js"
+import { UnitTypeClassifier } from "../classifier/UnitTypeClassifier.js"
+import { UnitTypeUnitClassifier } from "../classifier/UnitTypeUnitClassifier.js"
+import { OrphanedLevelTypeDeclassifier } from "../solver/OrphanedLevelTypeDeclassifier.js"
+import Parser, { ParserOptions } from "./Parser.js"
+
+export class AddressParser extends Parser {
+	constructor(options: Partial<ParserOptions> = {}) {
+		super(
+			// classifiers
+			[
+				// generic word classifiers
+				new AlphaNumericClassifier(),
+				new LevelTypeLevelClassifier(),
+				new UnitTypeUnitClassifier(),
+				new TokenPositionClassifier(),
+
+				// word classifiers
+				new LevelTypeClassifier(),
+				new UnitTypeClassifier(),
+				new HouseNumberClassifier(),
+				new LevelClassifier(),
+				new UnitClassifier(),
+				new PostcodeClassifier(),
+				new StreetPrefixClassifier(),
+				new StreetSuffixClassifier(),
+				new StreetProperNameClassifier(),
+				new RoadTypeClassifier(),
+				new ToponymClassifier(),
+				new CompoundStreetClassifier(),
+				new DirectionalClassifier(),
+				new OrdinalClassifier(),
+				new StopWordClassifier(),
+
+				// phrase classifiers
+				new IntersectionClassifier(),
+				new PersonClassifier(),
+				new GivenNameClassifier(),
+				new SurnameClassifier(),
+				new MiddleInitialClassifier(),
+				new PersonalSuffixClassifier(),
+				new PersonalTitleClassifier(),
+				new ChainClassifier(),
+				new PlaceClassifier(),
+				new WhosOnFirstClassifier(),
+
+				// composite classifiers
+				new CompositeClassifier(PersonScheme),
+				new CompositeClassifier(StreetNameScheme),
+				new CompositeClassifier(StreetScheme),
+				new CompositeClassifier(VenueScheme),
+				new CompositeClassifier(IntersectionScheme),
+
+				// additional classifiers which act on unclassified tokens
+				new CentralEuropeanStreetNameClassifier(),
+			],
+			// solvers
+			[
+				new ExclusiveCartesianSolver(),
+				new LeadingAreaDeclassifier(),
+				new MultiStreetSolver(),
+				new SubsetFilter(),
+				new InvalidSolutionFilter([
+					["HouseNumberClassification", "LocalityClassification"],
+					["HouseNumberClassification", "LocalityClassification", "RegionClassification"],
+					["HouseNumberClassification", "LocalityClassification", "CountryClassification"],
+					["HouseNumberClassification", "LocalityClassification", "RegionClassification", "CountryClassification"],
+					["HouseNumberClassification", "RegionClassification"],
+					["HouseNumberClassification", "RegionClassification", "CountryClassification"],
+					["HouseNumberClassification", "CountryClassification"],
+					["HouseNumberClassification", "PostcodeClassification"],
+					["HouseNumberClassification", "PostcodeClassification", "LocalityClassification"],
+					["HouseNumberClassification", "PostcodeClassification", "RegionClassification"],
+					["HouseNumberClassification", "PostcodeClassification", "CountryClassification"],
+					["VenueClassification", "HouseNumberClassification"],
+					["VenueClassification", "PostcodeClassification"],
+				]),
+				new MustNotFollowFilter("VenueClassification", "HouseNumberClassification"),
+				new MustNotFollowFilter("VenueClassification", "StreetClassification"),
+				new MustNotFollowFilter("VenueClassification", "LocalityClassification"),
+				new MustNotFollowFilter("VenueClassification", "RegionClassification"),
+				new MustNotFollowFilter("VenueClassification", "CountryClassification"),
+				new MustNotFollowFilter("VenueClassification", "PostcodeClassification"),
+				new MustNotPreceedFilter("PostcodeClassification", "HouseNumberClassification"),
+				new MustNotPreceedFilter("PostcodeClassification", "StreetClassification"),
+				new MustNotPreceedFilter("LocalityClassification", "HouseNumberClassification"),
+				new MustNotPreceedFilter("LocalityClassification", "StreetClassification"),
+				new MustNotPreceedFilter("RegionClassification", "HouseNumberClassification"),
+				new MustNotPreceedFilter("RegionClassification", "StreetClassification"),
+				new MustNotPreceedFilter("CountryClassification", "RegionClassification"),
+				new MustNotPreceedFilter("CountryClassification", "LocalityClassification"),
+				new MustNotPreceedFilter("CountryClassification", "PostcodeClassification"),
+				new MustNotPreceedFilter("CountryClassification", "StreetClassification"),
+				new MustNotPreceedFilter("CountryClassification", "HouseNumberClassification"),
+				new MustNotPreceedFilter("VenueClassification", "LevelClassification"),
+				new MustNotPreceedFilter("VenueClassification", "UnitClassification"),
+				new MustNotFollowFilter("LocalityClassification", "RegionClassification"),
+				new MustNotFollowFilter("LocalityClassification", "CountryClassification"),
+				new HouseNumberPositionPenalty(),
+				new PostcodePositionPenalty(),
+				new TokenDistanceFilter(),
+				new OrphanedLevelTypeDeclassifier(),
+				new OrphanedUnitTypeDeclassifier(),
+				new SubsetFilter(),
+			],
+			options
+		)
+	}
+}

package/parser/Parser.ts

@@ -0,0 +1,125 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+import { Classifier } from "../classifier/super/BaseClassifier.js"
+import Solution from "../solver/Solution.js"
+import { Solver } from "../solver/super/BaseSolver.js"
+import { Tokenizer } from "../tokenization/Tokenizer.js"
+
+export interface ParserOptions {
+	max_solutions: number
+}
+
+/**
+ * Parses a tokenized address into a structured address.
+ */
+class Parser {
+	public classifiers: Classifier[]
+	public solvers: Solver[]
+	public options: ParserOptions
+
+	constructor(classifiers: Classifier[], solvers: Solver[], options: Partial<ParserOptions> = {}) {
+		this.classifiers = classifiers
+		this.solvers = solvers
+
+		this.options = {
+			max_solutions: 10,
+			...options,
+		}
+	}
+
+	/**
+	 * Run all classifiers.
+	 */
+	classify(tokenizer: Tokenizer): void {
+		this.classifiers.forEach((c) => c.classifyTokenizer(tokenizer))
+	}
+
+	/**
+	 * Run all solvers.
+	 */
+	solve(tokenizer: Tokenizer): void {
+		for (const solver of this.solvers) {
+			this.scoreAndSort(tokenizer)
+
+			// run solver
+			solver.solve(tokenizer)
+		}
+
+		this.scoreAndSort(tokenizer)
+	}
+
+	/**
+	 * Score and sort solutions.
+	 */
+	scoreAndSort(tokenizer: Tokenizer) {
+		// recompute scores
+		tokenizer.solutions.forEach((s) => s.computeScore(tokenizer))
+
+		// sort pairs by span start
+		tokenizer.solutions.forEach((s) => s.pair.sort((a, b) => a.span.start - b.span.start))
+
+		// sort results by score desc
+		tokenizer.solutions.sort(this.comparitor)
+
+		// ensure that no more than $MAX_SOLUTIONS are retained
+		if (tokenizer.solutions.length > this.options.max_solutions) {
+			tokenizer.solutions = tokenizer.solutions.slice(0, this.options.max_solutions)
+		}
+	}
+
+	// @todo: possibly move the admin penalty scoring to another file
+	/**
+	 * Compare solutions for sorting
+	 */
+	comparitor(a: Solution, b: Solution): number {
+		// if scores are equal then enforce a slight penalty for administrative ordering
+		if (b.score === a.score) {
+			const areas = {
+				a: a.pair.filter((p) => {
+					return Object.hasOwn(p.span.classifications, "AreaClassification")
+				}),
+				b: b.pair.filter((p) => {
+					return Object.hasOwn(p.span.classifications, "AreaClassification")
+				}),
+			}
+
+			const classification = {
+				a: areas.a.length ? areas.a[0]?.classification.constructor.name : "",
+				b: areas.b.length ? areas.b[0]?.classification.constructor.name : "",
+			}
+
+			if (classification.a === "LocalityClassification") {
+				return -1
+			}
+
+			if (classification.b === "LocalityClassification") {
+				return 1
+			}
+
+			if (classification.a === "RegionClassification") {
+				return -1
+			}
+
+			if (classification.b === "RegionClassification") {
+				return 1
+			}
+
+			if (classification.a === "CountryClassification") {
+				return -1
+			}
+
+			if (classification.b === "CountryClassification") {
+				return 1
+			}
+		}
+
+		// sort results by score desc
+		return b.score - a.score
+	}
+}
+
+export default Parser

package/parser/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+export * from "./AddressParser.js"
+export * from "./Parser.js"
+export * from "./utils.js"

package/parser/utils.ts

@@ -0,0 +1,94 @@
+/**
+ * @copyright OpenISP, Inc.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ */
+
+import addressFormatter from "@fragaria/address-formatter"
+import { ClassificationMap, ClassificationRecord, PublicClassificationLabel } from "../classification/types.js"
+import { Tokenizer } from "../tokenization/Tokenizer.js"
+import { AddressParser } from "./AddressParser.js"
+
+type FragariaAddressProps = keyof Parameters<typeof addressFormatter.format>[0]
+
+const ClassificationToFragaria = new Map<PublicClassificationLabel, FragariaAddressProps>([
+	["venue", "attention"],
+	["street", "street"],
+	["country", "country"],
+	["housenumber", "housenumber"],
+	["locality", "locality"],
+	["postcode", "postcode"],
+	["region", "state"],
+])
+
+export function formatAddress(classifications: ClassificationMap) {
+	const props = new Map<FragariaAddressProps, string>()
+
+	for (const [classification, value] of classifications.entries()) {
+		const fragariaProp = ClassificationToFragaria.get(classification)
+
+		if (!fragariaProp) continue
+		if (!value) continue
+		if (props.has(fragariaProp)) continue
+
+		props.set(fragariaProp, value)
+	}
+
+	const formatted = addressFormatter.format(
+		Object.fromEntries(props),
+		// {
+		// 	attention: classifications.venue,
+		// 	street: classifications.street,
+		// 	country: classifications.country,
+		// 	housenumber: classifications.housenumber,
+		// 	locality: classifications.locality,
+		// 	postcode: classifications.postcode,
+		// 	state: classifications.region,
+		// 	// level: classifications.level,
+		// 	// level_type: classifications.level_type,
+		// 	// region: classifications.region,
+		// 	// unit: classifications.unit,
+		// 	// unit_type: classifications.unit_type,
+		// 	// venue: classifications.venue,
+		// },
+		{
+			// abbreviate: true,
+			// appendCountry: true,
+			countryCode: "US",
+			output: "array",
+		}
+	)
+
+	return formatted.join(", ")
+}
+
+export interface ParsedAddress {
+	classifications: ClassificationRecord
+	formatted_address: string
+}
+
+/**
+ * Parse an address input, preferably a well-formatted address.
+ */
+export function parseAddressInput(formattedAddress: string): ParsedAddress[] {
+	const tokenizer = new Tokenizer(formattedAddress)
+	const parser = new AddressParser()
+
+	parser.classify(tokenizer)
+	parser.solve(tokenizer)
+
+	const results: ParsedAddress[] = tokenizer.solutions.map(({ pair }) => {
+		const classifications: ClassificationMap = new Map()
+
+		for (const { classification, span } of pair) {
+			classifications.set(classification.label as PublicClassificationLabel, span.body)
+		}
+
+		return {
+			classifications: Object.fromEntries(classifications) as ClassificationRecord,
+			formatted_address: formatAddress(classifications),
+		}
+	})
+
+	return results
+}

package/resources/chromium-i18n/ssl-address/AC.json

@@ -0,0 +1,8 @@
+{
+	"zipex": "ASCN 1ZZ",
+	"key": "AC",
+	"name": "ASCENSION ISLAND",
+	"fmt": "%N%n%O%n%A%n%C%n%Z",
+	"zip": "ASCN 1ZZ",
+	"id": "data/AC"
+}

package/resources/chromium-i18n/ssl-address/AD.json

@@ -0,0 +1,16 @@
+{
+	"zipex": "AD100,AD501,AD700",
+	"sub_isoids": "07~02~03~08~04~05~06",
+	"key": "AD",
+	"name": "ANDORRA",
+	"fmt": "%N%n%O%n%A%n%Z %C",
+	"sub_names": "Andorra la Vella~Canillo~Encamp~Escaldes-Engordany~La Massana~Ordino~Sant Julià de Lòria",
+	"sub_zipexs": "AD500~AD100~AD200~AD700~AD400~AD300~AD600",
+	"lang": "ca",
+	"zip": "AD[1-7]0\\d",
+	"sub_keys": "Parròquia d'Andorra la Vella~Canillo~Encamp~Escaldes-Engordany~La Massana~Ordino~Sant Julià de Lòria",
+	"languages": "ca",
+	"posturl": "http://www.correos.es/comun/CodigosPostales/1010_s-CodPostal.asp?Provincia=",
+	"sub_zips": "AD50[01]~AD10[01]~AD20[01]~AD70[01]~AD40[01]~AD30[01]~AD60[01]",
+	"id": "data/AD"
+}

package/resources/chromium-i18n/ssl-address/AE.json

@@ -0,0 +1,15 @@
+{
+	"sub_lnames": "Abu Dhabi~Sharjah~Fujairah~Umm Al Quwain~Dubai~Ras al Khaimah~Ajman",
+	"lfmt": "%N%n%O%n%A%n%S",
+	"require": "AS",
+	"key": "AE",
+	"name": "UNITED ARAB EMIRATES",
+	"fmt": "%N%n%O%n%A%n%S",
+	"lang": "ar",
+	"sub_isoids": "AZ~SH~FU~UQ~DU~RK~AJ",
+	"sub_names": "أبو ظبي~الشارقة~الفجيرة~ام القيوين~دبي~رأس الخيمة~عجمان",
+	"sub_keys": "أبو ظبي~إمارة الشارقةّ~الفجيرة~ام القيوين~إمارة دبيّ~إمارة رأس الخيمة~عجمان",
+	"languages": "ar",
+	"state_name_type": "emirate",
+	"id": "data/AE"
+}

package/resources/chromium-i18n/ssl-address/AF.json

@@ -0,0 +1,8 @@
+{
+	"zipex": "1001,2601,3801",
+	"key": "AF",
+	"name": "AFGHANISTAN",
+	"fmt": "%N%n%O%n%A%n%C%n%Z",
+	"zip": "\\d{4}",
+	"id": "data/AF"
+}

package/resources/chromium-i18n/ssl-address/AG.json

@@ -0,0 +1 @@
+{ "key": "AG", "name": "ANTIGUA AND BARBUDA", "require": "A", "id": "data/AG" }

package/resources/chromium-i18n/ssl-address/AI.json

@@ -0,0 +1,8 @@
+{
+	"zipex": "2640",
+	"key": "AI",
+	"name": "ANGUILLA",
+	"fmt": "%N%n%O%n%A%n%C%n%Z",
+	"zip": "(?:AI-)?2640",
+	"id": "data/AI"
+}