リファレンス

解析・書式・共通の型

import { … } from "@johnmorrisdotca/address-plus";

最小化と gzip 圧縮をしたサイズは 105.7 kB（読み込むものをすべて含み、esbuild で計測）

リファレンスの説明と例は英語です。見出しと目次は日本語です。

エクスポート

名前	種類	概要
`AddressAbbreviations`	型	What `getAddressAbbreviations` returns: one map per kind of abbreviation.
`AddressComparisonOptions`	型	Options for comparing addresses: what to normalize before comparing, whether to allow small typos, and whether every field must match exactly.
`AddressComparisonResult`	型	What `compareAddresses` returns: the verdict, the match type and the similarity.
`AddressComparisonTestCase`	型	A comparison case in the package's JSON test files: two addresses and the match expected.
`AddressDifference`	型	One part on which two addresses differ, with both values and the kind of difference.
`AddressFormattingOptions`	型	Options for `formatAddress` and `cleanAddress`: what to abbreviate, capitals, the unit, the country and the line separator.
`AddressFormattingTestCase`	型	A formatting case in the package's JSON test files: an address and the text expected.
`AddressMatchType`	型	How strongly two addresses match, from `exact` to `none`.
`AddressParser`	型	The shape of the default export: the four parsers parse-address's users call on one object.
`AddressParsingTestCase`	型	A parsing case in the package's JSON test files: an address and the fields expected from it.
`AddressSimilarityResult`	型	How alike two addresses are: an overall score from 0 to 1, a score for each part, and the differences.
`AddressValidationResult`	型	What `validateAddress` returns.
`AddressValidationTestCase`	型	A validation case in the package's JSON test files: an address and the verdict and codes expected.
`AustralianAddressFields`	型	The fields an Australian address fills beside the shared ones.
`AustralianPostcodeRange`	型	One block of postcodes Australia Post allocates to a state or territory: every postcode from `from` to `to`, inclusive, written as four digits.
`AustralianState`	型	An Australian state or territory in the tables: Australia Post's code, the ISO 3166-2 code, and its name in English and in Japanese (from kuni, which takes them from Unicode CLDR and Wikidata).
`AustralianStateCode`	型	The code of an Australian state or territory, as Australia Post writes it on the last line of an address.
`BatchParseError`	型	One address a batch could not parse: its index, the input and the reason.
`BatchParseOptions`	型	Options for the batch parsers: the parse options, plus whether to stop at the first error and whether to include the statistics.
`BatchParseResult`	型	What a batch parser returns: the results in order, the errors and the statistics.
`BatchParseStats`	型	The counts and timing of a batch: how many were parsed, how many failed, and how long it took.
`BatchProcessingTestCase`	型	A batch case in the package's JSON test files: several addresses and the counts expected.
`buildRegexFromDict`	関数	A regular expression matching any key of a dictionary as a whole word, longest first.
`CA_PROVINCE_ALTERNATIVES`	定数	Other ways Canadian provinces are written (old and informal abbreviations such as `PQ`, `Que.`, `Nfld.`), in lower case, to their codes.
`CA_PROVINCE_NAMES`	定数	Every Canadian province and territory by its English or French name, to its code.
`CA_PROVINCE_NAMES_EN`	定数	Every Canadian province and territory by its English name in lower case, to its two-letter code.
`CA_PROVINCE_NAMES_FR`	定数	Every Canadian province and territory by its French name in lower case, to its two-letter code.
`CA_PROVINCES`	定数	Every name and other spelling of a Canadian province, to its code: the names and the alternatives together.
`CA_REGIONS`	定数	Every name and other spelling of a Canadian province or territory as a `Region` object, for fuzzy matching by `normalizeRegion`.
`CA_STREET_TYPES`	定数	Every street type Canada Post lists, in English and French, with common spellings, in lower case, to the abbreviation the parser reports.
`CanadaPostFormattingOptions`	型	Options for `formatCanadaPost`: which lines to include, bilingual labels, and whether to set the letter case the Canada Post way.
`CANADIAN_POSTAL_CODE_PATTERN`	定数	A Canadian postal code with the letters Canada Post assigns, with or without its space.
`CANADIAN_POSTAL_LIBERAL_PATTERN`	定数	A Canadian postal code of any letters, for finding one before it is checked.
`capitalizeStreetName`	関数	Capitalizes a street name the way it is signed.
`capitalizeWords`	関数	Capitalizes the first letter of each word.
`CITY_PATTERNS`	定数	Patterns for a city of one or more words at the end of a text, after a space, used where no comma marks it.
`cleanAddress`	関数	Tidies an address typed in a hurry: spaces, commas, letter case, the street type and the state, without changing what it says.
`cleanAddressDetailed`	関数	Tidies an address like `cleanAddress`, and says what it changed.
`CleanAddressOptions`	型	Options for `cleanAddress`: which tidying to do, and the letter case to set.
`CleanAddressResult`	型	What `cleanAddressDetailed` returns: the tidied address and what changed.
`CleanAddressTestCase`	型	A cleaning case in the package's JSON test files: an address and the tidied text expected.
`COMMON_PARSER_PATTERNS`	定数	Pattern builders the parsers share: a ZIP, a state or a postal code at the end of a text, and a city before a state.
`COMMON_STREET_NAMES_PATTERN`	定数	Street names common enough that they must not be taken as part of a city's name.
`compareAddresses`	関数	Compares two parsed addresses field by field, allowing for abbreviations (Street and St), state names and codes, letter case and small typos.
`CONNECTOR_WORDS`	定数	Small words (`of`, `the`, `and`) that may be in lower case inside a facility's name written in title case.
`COUNTRIES`	定数	The country codes the parser reports: `US`, `CA` and `JP`.
`CountryCode`	型	A country code the parser reports: `US`, `CA` or `JP`.
`CountryComparison`	型	What a country module's comparer returns: whether the two addresses are the same delivery point, and every field that differs once both are in the same form (letter case, punctuation, a street type written out or abbreviated).
`CountryDifference`	型	One way two addresses differ, as a country module's comparer reports it: the field, and its value in each address after both were put in the same form.
`CountryModule`	型	A country's address module: its codes, how to tell its addresses apart, and its parser, validator, formatter and comparer.
`CountryValidation`	型	What a country module's validator returns: the errors and the warnings it found.
`default`	定数	The default export, shaped like parse-address's module: `parseLocation`, `parseAddress`, `parseIntersection` and `parseInformalAddress` on one object, so `import parser from "@johnmorrisdotca/address-plus"` works where parse-address was imported.
`detectCountry`	関数	Which country a parsed address is in, from its postal code, then its state or province.
`DIRECTION_EXPANSIONS`	定数	Each directional abbreviation in lower case, to the word in full.
`DIRECTIONAL_MAP`	定数	Each directional word, in English or French, in lower case, to its abbreviation (`northwest` and `nord-ouest` to `NW` and `NO`).
`FACILITY_DELIMITER_PATTERN`	定数	A facility's name followed by a comma or a dash and then the address.
`FACILITY_DELIMITER_PATTERNS`	定数	The ways a facility's name is set off from an address: in parentheses, before a delimiter, or as a trailing island.
`FACILITY_INDICATORS`	定数	Words that mark a place's name as a facility (`center`, `tower`, `hospital`, `université`), in lower case.
`FACILITY_PATTERNS`	定数	The patterns that find a facility's name, in English and French.
`findMunicipalitiesByName`	関数	The municipalities a Japanese name could mean: several when the name is shared (`府中市` is in Tokyo and in Hiroshima).
`findMunicipalitiesByRomaji`	関数	The municipalities a romaji name could mean, written with or without macrons and designators (`Chiyoda-ku`, `Chiyoda City`, `Sapporo-shi Chuo-ku`, `Chuo-ku, Sapporo`).
`findMunicipalityByCode`	関数	The municipality with a JIS X 0402 code, a designated city's own code included.
`findPrefecture`	関数	The prefecture a name, reading, romaji spelling or JIS code refers to: `東京都`, `東京`, `トウキョウト`, `Tokyo`, `Osaka Prefecture`, `13`.
`formatAddress`	関数	Writes a parsed address back out as lines and as one line, with abbreviations or in full.
`formatCanadaPost`	関数	Writes a parsed address the way Canada Post asks: capitals, the unit before the civic number joined by a hyphen, and the postal code two spaces after the province.
`formatJapanese`	関数	Writes a Japanese address in Japanese order, as an envelope is addressed: `〒100-0005`, then `東京都千代田区丸の内1-2-3`, then `サンプルビル5階501号室`.
`formatJapaneseEnglish`	関数	Writes a Japanese address in English order, as a form from abroad expects: building, room, block, town, municipality, prefecture, postal code, Japan.
`FormattedAddress`	型	A formatted address: its lines, and the same on one line.
`formatUSPS`	関数	Writes a parsed address the way USPS Publication 28 asks: capitals, standard abbreviations, the unit on the street line, and the city, state and ZIP+4 on the last.
`FRENCH_PREPOSITIONS`	定数	French particles that can open a street name, each with the space after it, to the way it is written there (`de la` as `De la` ).
`FrenchAddressFields`	型	The fields an address in France fills beside the shared ones.
`FrenchCollectivity`	型	An overseas collectivity of France in the tables: its code (`987`), the ISO 3166-1 country code an address in it reads as (`PF`) and its name.
`FrenchDepartment`	型	A department of France in the tables: its code (`75`, `2A`, `971`), its name and its region's, from INSEE's Code officiel géographique.
`FrenchPostalCountry`	型	The country an address in La Poste's base belongs to: `FR` for France (the metropolis and the overseas departments), `MC` for Monaco, and the ISO 3166-1 code of an overseas collectivity (`PM`, `BL`, `MF`, `WF`, `PF`, `NC`), which is French but has a country code of its own and is listed apart by the Universal Postal Union.
`FrenchPostcode`	型	A postcode taken apart: the code of the department or territory its number belongs to, the country it delivers to, and whether La Poste's base has it.
`FuzzyMatchOptions`	型	Settings for fuzzy string matching: the lowest similarity that counts, the largest edit distance, and phonetic matching.
`GENERAL_DELIVERY_PATTERNS`	定数	General delivery written alone or before a city.
`GermanAddressFields`	型	The fields an address in Germany fills beside the shared ones.
`GermanPostcode`	型	A postcode taken apart: the Land it is in, and whether GeoNames' list has it.
`GermanState`	型	A Land of Germany in the tables: its code, its ISO 3166-2 code, and its name in English and in Japanese (from kuni, which takes them from Unicode CLDR and Wikidata).
`GermanStateCode`	型	The code of one of the sixteen Länder of Germany, as ISO 3166-2:DE writes it after `DE-`.
`getAddressAbbreviations`	関数	Every abbreviation the formatters use: street types, directionals, secondary units, states and provinces.
`getAddressSimilarity`	関数	The similarity of two parsed addresses, part by part, without a verdict: the score and each part's score, and the differences.
`getPostalPrefixesForPrefecture`	関数	The three-digit postal prefixes a prefecture's codes begin with, the reverse of `getPrefectureFromJapanesePostalCode`.
`getPostalPrefixesForProvince`	関数	The postal code prefixes a province or territory uses, the reverse of `getProvinceFromPostalCode`.
`getPrefectureFromJapanesePostalCode`	関数	The prefecture a Japanese postal code delivers to, from Japan Post's data: by its first three digits, and for the codes on the far side of a prefix that straddles a border, by the whole code.
`getProvinceFromPostalCode`	関数	The province or territory a Canadian postal code is in, from its first letter, and for the X codes of the north, its first three characters.
`getStateFromZip`	関数	The state or territory a US ZIP code is in.
`getValidationErrors`	関数	The errors `validateAddress` finds, without the rest of its result.
`getZipPrefixesForState`	関数	The ZIP code prefixes a state or territory uses, the reverse of `getStateFromZip`: three digits where a whole block of a hundred belongs to it, five where only part of one does.
`hasValidAddressComponents`	関数	Whether a string looks like an address at all: a number and a street, a PO box, a postal code or another recognised part.
`INTERSECTION_PATTERNS`	定数	The regular expressions and pattern builders the intersection parser uses to find the city and each street with its type.
`ISLAND_TYPE_PATTERN`	定数	The words for an island, for addresses on one (`Island`, `Isle`, `Île`).
`isSameAddress`	関数	Whether two parsed addresses are the same place, by the same rules as `compareAddresses`.
`isValidAddress`	関数	Whether an address passes `validateAddress`.
`JapaneseAddressFields`	型	The fields a Japanese address fills on top of the shared ones.
`JapaneseEnglishFormattingOptions`	型	Options for `formatJapaneseEnglish`.
`JapaneseFormattingOptions`	型	Options for `formatJapanese`.
`JapaneseMunicipality`	型	A municipality (市区町村) in the tables: its JIS code, its prefecture's code, its official name with the district for a town or village in one, its reading and its romaji.
`JapanesePrefecture`	型	A prefecture (都道府県) in the tables: its JIS code, official name, katakana reading and romaji.
`JapaneseValidation`	型	What `validateJapaneseAddress` returns: the errors and the warnings found.
`JP_DESIGNATED_CITIES`	定数	The twenty designated cities (政令指定都市) as municipalities of their own.
`JP_MUNICIPALITIES`	定数	Every municipality (市区町村) by JIS X 0402 code, with its prefecture, official name, reading and romaji; a designated city's wards are listed, and the city itself is in `JP_DESIGNATED_CITIES`.
`JP_POSTAL_EXCEPTIONS`	定数	The postal codes that deliver to another prefecture than the rest of their three-digit prefix, each to that prefecture's JIS code.
`JP_POSTAL_PREFIXES`	定数	Each three-digit postal prefix, to the JIS code of the prefecture most of its codes deliver to.
`JP_PREFECTURES`	定数	The 47 prefectures in JIS X 0401 order, each with its code, official name, katakana reading and romaji.
`kanjiNumeralsToDigits`	関数	Turns the kanji numerals that stand for block, floor or room numbers into digits: `一丁目二番三号` becomes `1丁目2番3号`.
`looksJapanese`	関数	Whether a text is a Japanese address: in Japanese script, ending with Japan, or naming a prefecture beside a Japanese postal code, a romaji designator (`-ku`, `-shi`) or a municipality written with an English word (`Chiyoda City`).
`municipalitiesOf`	関数	Every municipality of a prefecture, the designated cities included.
`MUSIC_SQUARE_EAST_PATTERN`	定数	Nashville's Music Square East, whose name ends in a directional word that is part of it.
`normalizeJapaneseAddressText`	関数	Makes the text of a Japanese address uniform, as the parser reads it: widths folded, spaces tidied, numerals as digits, and `1の2の3`, `１－２－３` or any other dash written `1-2-3`.
`normalizeRegion`	関数	Finds the US state or Canadian province a name, code or misspelling means: `Calfornia`, `Que.`, `British Columbia`, `nfld`.
`normalizeStateProvinceName`	関数	The code of a US state or Canadian province written in full, in lower case.
`normalizeText`	関数	Lower-cases a string, turns its periods, commas and semicolons into spaces, folds runs of spaces to one and trims it: the form the parsers compare words in.
`PARENTHETICAL_PATTERN`	定数	Words in parentheses inside an address; group 1 is what is inside them.
`parseAddress`	関数	Parses a street address.
`parseAddresses`	関数	Parses many street addresses with `parseAddress`, in order.
`parseAddressesBatch`	関数	Parses many street addresses with `parseAddress`, and reports which failed and how long it took.
`ParsedAddress`	型	What `parseLocation` returns: every part it found, each absent when the address has none.
`ParsedIntersection`	型	What `parseIntersection` returns: two streets, each with its name, type and directionals, and the place.
`parseDirectional`	関数	Takes a leading directional off a street (`NW Main St`), abbreviated.
`parseFacility`	関数	Takes a facility's name (a building, a park, a hospital) off the start of an address.
`parseInformalAddress`	関数	Reads an address written loosely, as a fallback when `parseLocation` finds no street address: a description such as `Downtown near City Hall` is kept whole as the street, with any ZIP code after it.
`parseInformalAddresses`	関数	Parses many loosely written addresses with `parseInformalAddress`, in order.
`parseInformalAddressesBatch`	関数	Parses many loosely written addresses with `parseInformalAddress`, and reports which failed and how long it took.
`parseIntersection`	関数	Parses an intersection of two streets, joined by `&`, `and`, `at` or `@`, with the city, state and ZIP that may follow.
`parseIntersections`	関数	Parses many intersections with `parseIntersection`, in order.
`parseIntersectionsBatch`	関数	Parses many intersections with `parseIntersection`, and reports which failed and how long it took.
`parseJapaneseAddress`	関数	Parses a Japanese address, in Japanese script or in romaji, into the Japanese fields and the shared ones.
`parseLocation`	関数	Parses a US, Canadian or Japanese address into its parts.
`parseLocations`	関数	Parses many addresses with `parseLocation`, in order.
`parseLocationsBatch`	関数	Parses many addresses with `parseLocation`, and reports which failed and how long it took.
`ParseOptions`	型	Options for every parser: the country, strict postal codes, snake_case keys and the rest.
`parseParenthetical`	関数	Takes words in parentheses out of an address, such as `(Rear Entrance)`.
`parsePostalCode`	関数	Takes a ZIP code, ZIP+4 or Canadian postal code off the end of a text.
`parseSecondaryUnit`	関数	Takes a secondary unit (apartment, suite, floor and the rest) off a street line.
`parseStateProvince`	関数	Takes a US state or Canadian province off the end of a text, by code or by name.
`parseStreetNumber`	関数	Takes the house number off the start of a street line, with a fraction or a letter if it has one.
`parseStreetType`	関数	Takes the street type off the end of a street, abbreviated the USPS way.
`PO_BOX_PATTERNS`	定数	The regular expressions the PO box parser uses: the box itself, a station after it, a box number first, and a trailing comma.
`POSTAL_CODE_TO_PROVINCE`	定数	Each first letter of a Canadian postal code, to the province or territory it is assigned to.
`PostalValidationResult`	型	What `validatePostalCode` returns: whether the code is well formed, its type, and the code written the standard way.
`PROVINCE_EXPANSIONS`	定数	Each Canadian province's code in lower case, to its name in lower case: English by default, the French names under their own keys.
`PROVINCE_EXPANSIONS_EN`	定数	Each Canadian province's code in lower case, to its English name in lower case.
`PROVINCE_EXPANSIONS_FR`	定数	Each Canadian province's code in lower case, to its French name in lower case.
`Region`	型	A US state or Canadian province: its code, its country and its name, as `normalizeRegion` matches them.
`SECONDARY_UNIT_PATTERN`	定数	A unit at the end of a street line: group 1 is the street before it, group 2 the unit.
`SECONDARY_UNIT_TYPES`	定数	Each secondary unit designator, abbreviated or in full, in lower case, to the word the parser reports in full: USPS Publication 28 Appendix C2, and Canada Post's French unit words, which stay French.
`setValidatedPostalCode`	関数	Sets a ZIP or postal code on a result, the way the parsers do: split into ZIP and ZIP+4, a Canadian code in capitals with one space, with `zipValid` set, and in strict mode only when the code is well formed.
`StateCode`	型	A US state, DC or territory code that `getStateFromZip` can return.
`STREET_NAME_ACRONYMS`	定数	Acronyms written in capitals inside a street name (`US`, `FBI`), from their lower-case form, for `capitalizeStreetName`.
`STREET_TYPE_DETECTION_PATTERN`	定数	Whether a text has a common street type in it, used to judge that a parse found a street.
`STREET_TYPE_EXPANSIONS`	定数	Each USPS street type abbreviation in lower case, to the word in full.
`STREET_TYPE_PROPER_CASE`	定数	Each street type abbreviation in lower case, to the way the parser reports it (`Ave`, `Xing`).
`SubRegion`	型	An administrative part of a city (a borough, a parish, a ward, an arrondissement) that may be written where the city is expected.
`TERRITORY_POSTAL_PREFIXES`	定数	The first three characters of each territory's postal codes, since the territories share a first letter.
`TERRITORY_POSTAL_RANGES`	定数	The patterns that tell the Northwest Territories' X codes from Nunavut's, by their first three characters.
`TestCase`	型	Any case in the package's JSON test files.
`TestCaseBase`	型	The fields every case in the package's JSON test files has: a name or description, the input, what is expected and the options.
`UKAddressFields`	型	The fields an address in the United Kingdom fills beside the shared ones.
`UKNation`	型	A nation of the United Kingdom in the tables: its code, its ISO 3166-2 code, and its name in English and in Japanese (from kuni, which takes them from Unicode CLDR and Wikidata).
`UKNationCode`	型	The code of one of the four nations of the United Kingdom, as ISO 3166-2:GB writes it after `GB-`.
`UKPostcode`	型	A postcode taken apart: the outward code (area and district) and the inward code (sector and unit), and where it delivers.
`UNIT_TYPE_KEYWORDS`	定数	The secondary unit designators that take a value after them, as one alternation for a regular expression, longest first so that `apartment` is tried before `apt`: USPS Publication 28 Appendix C2, Canada Post's English and French unit words, and a few spellings people write.
`UNIT_TYPE_NUMBER_PATTERN`	定数	A unit's designator and value: groups 1 and 2 (`apt 123`, `Apt.
`US_REGIONS`	定数	Every name and other spelling of a US state, DC or territory as a `Region` object, for fuzzy matching by `normalizeRegion`.
`US_STATE_ALTERNATIVES`	定数	Other ways US states are written (shortened forms, old abbreviations, `D.C.`), in lower case, to their codes.
`US_STATE_EXPANSIONS`	定数	Each US state's code in lower case, to its name in lower case: the reverse of `US_STATE_NAMES`.
`US_STATE_NAMES`	定数	Every US state, DC and territory by its name in lower case, to its two-letter code.
`US_STATES`	定数	Every name and other spelling of a US state in lower case, to its code: `US_STATE_NAMES` and `US_STATE_ALTERNATIVES` together.
`US_STREET_TYPES`	定数	Every street type USPS Publication 28 lists, and the common spellings of each, in lower case, to its USPS abbreviation in lower case.
`USPSFormattingOptions`	型	Options for `formatUSPS`: which lines to include, and whether to set the letter case the USPS way.
`validateAddress`	関数	Checks an address: whether it has what an address needs, whether its ZIP or postal code is well formed and belongs to the state, province or prefecture named, and how sure the parser is.
`validateJapaneseAddress`	関数	Checks a parsed Japanese address against the tables: the postal code's shape, whether any code begins with its first three digits, whether it delivers to the prefecture named, and whether the municipality is a real one in that prefecture.
`validatePostalCode`	関数	Checks the shape of a US ZIP code or a Canadian postal code.
`VALIDATION_PATTERNS`	定数	Small regular expressions the validators share: letters, digits, a house number at the start, and the like.
`ValidationError`	型	One finding of a validator: the field it is about, its code, a message, and how serious it is.
`ValidationOptions`	型	Options for the validators: which parts an address must have, which kinds are allowed, and whether a postal code that does not match its region is an error.
`WRITTEN_NUMBERS`	定数	House numbers written as words (`One`, `Twenty`), as one alternation for a regular expression, so `One Microsoft Way` is read as number 1.
`ZIP_CODE_PATTERN`	定数	A US ZIP code with an optional ZIP+4.
`ZIP_CODE_REGEX_PATTERN`	定数	The source of `ZIP_CODE_PATTERN`, for building larger patterns.
`ZIP_VALIDATION_PATTERNS`	定数	The shape of something that could be a ZIP code.

ソースを見る GitHub で編集@johnmorrisdotca/address-plus 1.7.0 のソースから作成しました。

この日本語は、まだ日本語を母語とする方の確認を受けていません。訂正を歓迎します。