PlistEdit Pro is a replacement for the embedded plist editor included in Xcode. While Xcode does the job, it is rather limited in its functions and it can be frustrating to work with its strictly basic functionality. PlistEdit Pro offers advanced features such as:
Property lists are used extensively in macOS and iOS. They can be used to store user preferences, configuration information for your system, and information in your installed applications. A property list is a hierarchical data structure made up of seven different types of data:
Property lists can be stored in files in several different formats: XML, ASCII, or binary. The most common form is XML, which is both human readable and flexible enough to represent all seven types of data that occur in property lists. The ASCII format for property lists is a little easier to read and edit, but some of the data types (boolean, date, and number) cannot be stored in this format (the ASCII format is also deprecated in macOS 10.6 and later). The binary format takes up the least space on disk and can represent all data types, but is not easily readable or editable.
More details on the use of property lists in macOS and iOS can be found on Apple’s site: Property List Programming Guide
The types of data that can be represented in JSON are nearly identical to those supported by plists, with the following exceptions:
When working with JSON files in PlistEdit Pro, you can perform all the same operations that you can with regular plists, such as copy/paste, drag and drop, find/replace, and so forth. PlistEdit Pro can also be used to convert data between plist and JSON formats.
Editing a property list is fairly straightforward. You can edit existing values by double clicking the text in the value column (or for boolean values, a pop-up menu is provided instead). For items contained in a dictionary, you can edit the keys by double clicking the key. You can also change the type of an existing data item by selecting an item from the pop-up menu in the Class column. When you change an item from one class to another, PlistEdit Pro will do its best to convert the old data into the new format, e.g. changing the boolean value YES to a string valued “YES”.
Adding new data items to the list can be done through the New Sibling and New Child commands, available in both the toolbar and the Operations menu. You can also move or copy items by dragging them to a different position in the list, or by copying and pasting selected items.
Editing large values
The Edit Value command, available in the Edit menu, will open a sheet with a larger text view, allowing you to edit larger values that are difficult to edit in the confines of a single row editing field. You can also select multiple items in a property list that are of the same class and use the Edit Value command to assign a single value to all the selected items at once.
PlistEdit Pro provides an autocompletion feature that makes entering information easier. If you are using a structure definition when editing a plist, PlistEdit Pro will include any keys that are specified in that definition. For example, if you are editing an Info.plist file, and type “CF”, PlistEdit Pro will provide completions for all the common keys that start with CF (e.g. CFBundleName, CFBundleVersion, CFBundleDocumentTypes, etc.).
PlistEdit Pro also provides several convenient keyboard shortcuts which allow you to edit anything in your property list without ever leaving the keyboard.
|Property list navigation|
|Expand the currently selected item(s)||Right arrow|
|Expand the currently selected item(s) and all of their children, recursively||Option-right arrow|
|Collapse the currently selected item(s)||Left arrow|
|Collapse the currently selected item(s) and all of their children, recursively||Command-left arrow|
|Select the dictionary or array containing the selected item||Command-up arrow|
|Begin editing the key in the currently selected row||Tab|
|Edit the currently selected value(s) in a separate sheet||Command-Shift-E|
|Advances editing to the next editable cell, going left to right||Tab|
|Ends the current editing session, saving changes||Return|
|Ends the current editing session, discarding changes||Escape|
|Pop-up the menu in the currently selected cell||Space|
|Property list browsers|
|Open the selected files||Return|
PlistEdit Pro supports finding and replacing text both within individual keys and values in a property list and in the full text version of the property list file, i.e. the raw XML or JSON. Simply click the view you want to search in (outline or text) and press command-F to bring up the find bar, where you can enter a string to search for. Clicking the small magnifying glass next to the search field will provide menu with options such as case sensitivity, wrap around, and restricting search results to the beginning or entirety of a key or value.
PlistEdit Pro provide a number of different ways to sort your property lists, making it easier to browse through larger lists and find various items. Note that sorting a dictionary will not be persisted when saving the property list, since dictionaries are always saved with their keys sorted alphabetically. The order of sorted arrays will be saved though.
Selecting a dictionary and selecting the “Sort Keys” command from the Operations menu will rearrange the objects in the dictionary in order by their keys. Dictionaries are sorted alphabetically by default when opening a property list, but this order can be changed when renaming items or creating new items, so this allows you to restore the sort order. Additionally, the “Sort All Keys” menu command will apply the same sorting to all dictionaries in the entire property list.
Similarly, the “Sort Values” command will sort items in either an array or dictionary by the “Value” column, rather than the “Key” column. If the array/dictionary contains objects of mixed types (e.g. some strings, some numbers, some dates, etc.) the items will be grouped by type, and then sorted within each type.
Sort By Subkey
The “Sort By Subkey” command can be used on an array or dictionary containing only dictionaries, and will sort those dictionaries based on a particular key that those dictionaries contain. For example, if you are editing an Info.plist file for a document based application and select the array of document types supported by the application, you can sort that list by any of the keys that appear in the document type dictionaries, e.g. “CFBundleTypeName”, “NSDocumentClass”, etc. PlistEdit Pro will reorder the dictionaries sorted based on the key you select. Any dictionaries that don’t contain a value for that key will be sorted to the end of the list. This can be combined with the “View By Subkey” command to easily browse through large lists of dictionaries based on any key contained by those dictionaries.
The preferences window allows you to specify whether you want your sorting to be performed case sensitively or numerically. Case sensitive sorting will sort all capital letters before lowercase letters, and numeric sorting will sort numbers based on their numeric value, rather than treating them as alphabetic strings.
Property lists allow for storage of a wide variety of different data types. There are only seven basic types to work with, but data can be manipulated in many different ways to be stored as one of these seven types. However, this sometimes means transforming the data into a form that is not easily recognized or edited when viewing the property list.
PlistEdit Pro helps alleviate this problem by providing formatters for many common types of data that have to be manipulated to be stored in a property list. To view a value using a formatter, select the row you want to view and select the data type you want to view it as using the “View As” submenu in the Edit menu (or by control-clicking and selecting from the contextual menu). Below is a list of the formatters that are included with the current version of PlistEdit Pro:
|HMS (hours/minutes/seconds)||If a time value is stored in a number, this formatter can be used to interpret the number as a number of seconds and display the value divided up into hours, minutes, and seconds. For example, if the base value of the number is 3672, using the HMS formatter will display the value as 1:01:12 (one hour, one minute, and twelve seconds).|
|Hex (big-endian or little-endian)||Displays the number value as either big-endian or little-endian hexadecimal. Values are interpreted as signed integers and padded with zeros up to the nearest number of bytes that is a power of two. Any decimal portion of a floating-point number will be ignored.|
|OSType (a.k.a. four character codes)||OSType values are used in many ways in macOS as an easily readable four character code that is actually stored as a 32 bit integer. These values are often stored in property lists as their numeric value, which is not easily readable. Using this formatter will interpret and display a number as a four character OSType.|
|Storage size||Useful for numbers used to store file sizes as a raw number of bytes. The storage size formatter will instead display the number as a number of KB, MB, GB, or TB.|
|Time interval date||While property lists do provide a specific date type for storing dates, in some places you will still see dates stored as a time interval from a certain starting date. PlistEdit Pro provides formatters for interpreting these numbers as UNIX-style dates, using a reference date of 1/1/1970, Cocoa-style dates, which use a reference date of 1/1/2001, or Carbon style dates, which start at 1/1/1904.|
|Alias record||An alias record in macOS is an opaque data type that can be stored as a chunk of data. The most common storage method is in the resource fork of the alias files you can create using the Finder, but many programs also store aliases internally using data objects in property lists. This formatter will attempt to interpret the data object as an alias record and display the path the alias resolves to. If the data object is not an alias, or cannot be resolved, an error message is displayed instead of the path.|
|Strings (ASCII, MacOS Roman, UTF-8, or UTF-16)||This set of formatters will interpret the data object as a string encoded using a certain encoding.|
|Bookmark data||Bookmarks are data type that function very similarly to aliases, but are accessed through the CFURL/NSURL APIs. This formatter behaves the same as the one for alias records, only translating to/from bookmark data blobs instead of alias record data blobs.|
Note that not only do formatters allow you to view data as different types, they also allow you to edit the data in the same form. For example, you can type in a new hex value for a number, or type in a new path to make an alias record point to a different location.
View By Subkey
When viewing a list of dictionaries, it’s often difficult to find a particular dictionary, since the only value that’s displayed by default for each dictionary is the number of key/value pairs it contains. If you select such a list and use the “View By Subkey” menu command, you can select a key whose value will be displayed next to the dictionary. This makes it easy to find a particular dictionary in a large list without having to open each dictionary to see its contents.
While PlistEdit Pro allows you to edit property lists without needing to fiddle with their textual representations, it does allow you to edit the raw XML/ASCII text of the property list if you want to. The text for a property list is displayed in the bottom half of the document window, and you can edit the text directly from inside the document window. If you’ve modified the text, you will need to click the “Sync Outline” button in order to update the outline view to reflect the changes you have made in the text view. If the edits you’ve performed have left the text in an unparsable state, PlistEdit Pro will inform you when you try to sync the outline view, or save the document. The error message will typically contain a line number where the error was found, in which case you can use the “Go To Line” command in the Edit menu to go to that line in the text to find and fix the error.
Similarly, the “Sync Text” button will update the textual representation to reflect any changes you’ve made in the outline view above. Checking “Automatically sync text” checkbox will regenerate the text after every single change you make in the outline view. Note however that this may cause slowdowns when working with large property lists.
Also, when working with the JSON format, you have a preference whether you want the text to display the JSON text as condensed (i.e. with all whitespace stripped out), or indented (i.e. a more easily readable format, with each data item on its own line).
PlistEdit Pro allows you to easily examine many property lists at once through its property list browser. There are two ways in which you can create a new browser:
Once the browser is open, it will display the list of property list files you’ve added to it. To add more files to an open browser, simply drag the files or folders from the Finder into the browser’s list. To open a file shown in the list, just double click on its row in the list, or select one or more files and press the Return key.
Along with the file’s name, you can also see a number of each file’s attributes in the other columns in the table. To customize which of these columns are visible, use the pop-up menu by clicking on the small triangle in the upper right hand corner of the list. You can also sort the list by one of these properties by clicking on the header of that column (click a second time to reverse the sort order).
The following columns are available:
If you have a large number of files in a browser, you can use the browser’s search features to narrow down the list and easily find the particular file you’re looking for. Type something into the search field at the bottom of the window, and PlistEdit Pro will search the list of files for ones matching what you’ve typed. You can search in one of two ways, either by the file’s name, or by its content, chosen by clicking one of the radio buttons just below the search field.
When searching by content, the search will open up all the property list files in the list and look for the given text within the content of the property list. Clicking the “Options…” button will display several ways to customize how it performs the search:
Clicking the “Save As Default” button will save the current search options as the default ones to be used whenever a new browser is created.
Whenever you create a property list browser and add files or folders to it, PlistEdit Pro remembers which files and folders you dragged into that browser. You can later add or remove items by clicking the “Edit Content” button in the browser’s toolbar. After you have added or removed items, PlistEdit Pro will update the file list by rescanning all the files and folders you’ve specified.
After you’ve configured a browser, you can save that configuration so that you can later reopen that same browser and view the files contained in it. For example, if you are working on a project that uses a number of property list files, you can save a browser that is set to browse the contents of your project folder. Anytime after that, you can then reopen that browser to edit any of the property list files in your project without having to find the individual files again.
You can click the “Save Browser” button in a browser’s toolbar to save the current configuration of that browser under a name of your choice. That configuration will now show up in the submenu of the “Open Saved Browser” menu item in the “Browser” menu, and selecting it will restore the saved browser and rescan any folders it is set to browse. You can also rename and delete existing browser configurations by selecting “Organized Saved Browsers…” from the “Browser” menu.
Most macOS applications store their preferences in property list files, making them easy to view and edit. PlistEdit Pro offers a special property list browser that allows you to quickly locate and edit the preferences for many applications on your system. The preferences browser works much the same as a normal property list browser, but with a few added options.
In macOS, preference files are stored for the most part in a single folder at ~/Library/Preferences. When you open up the preferences browser (available through the Window menu), PlistEdit Pro will scan your preferences folder for all the preferences that are stored as property lists and display them to you in a list. You can also see the name of the application to which a particular preferences file belongs, making it much easier to find the file you need for a particular application. To edit a preferences file, simply double click on it in the list.
In addition to the normal search capabilities of a property list browser, the preferences browser offers a couple additional ways to narrow down the list of files you’re looking at. Clicking the checkbox titled “Show only prefs for known applications” will filter out any preferences file for which the system cannot find the corresponding application. This can be useful for filtering out old preferences files for applications that are no longer on the system.
While most preferences are stored on a user by user basis, some preferences can also be shared system-wide. These preferences are stored in /Library/Preferences, and can also be viewed in the preferences browser by checking the checkbox titled “Show system-wide preferences” at the bottom of the window. The preferences browser also provides an additional column (titled “File Type”) which lets you see which preferences files are specific to the current user, and which are system-wide.
The toolbar buttons at the top of the window provide some addition useful functions that act on the preference file you currently have selected in the list:
PlistEdit Pro offers a favorites menu to which you can add your most frequently used property list files for easy access. The Favorites menu is located in the File menu. If you have a property list file open that you want to add to your favorites, simply press Command-T, and the frontmost property list document will be added to the list. For further management of your favorites list, press Command-Shift-T, and a property list browser will open up displaying your favorites list.
Just like in any other property list browser, you can search your favorites list either by filename or by content. The favorites browser also allows you to assign a keyboard shortcut (Command-0 through Command-9) to the items in your favorites list. To change an item’s shortcut, just choose one from the Shortcut column’s pop-up menu for that item’s row. You can also add files to your favorites list by dragging them into the favorites browser, and you can remove an item by selecting it and clicking the “Remove” button in the browser window’s toolbar.
There are many common uses of property lists in which the property list must be structured in a certain way. For example, when editing a .scriptSuite file which is necessary for a developer to add Applescript support to their application, only a small set of keys are used, and the values stored must conform to certain types. To help create and edit lists with predefined structures such as this, property list structure definitions can be greatly helpful.
Using a structure definition when editing your property lists provides several additional enhancements and features.
Choosing from a list of available keys
Some types of property list can involve a large number of different keys, which can be difficult to keep track of and result in digging through the documentation, trying to figure out what the exact key you need for a particular purpose is. Structure definitions document the commonly used keys in certain types of property list files, and allow you to select such a key from a list directly from the PlistEdit Pro interface, rather than having to look it up in the documentation. For example, when editing an Info.plist file, PlistEdit Pro will already know commonly used keys such as CFBundleName, NSPrincipalClass, CFBundleDocumentTypes, LSUIElement, and so forth. This functionality can be accessed in a few different ways:
Human readable keys
Structure definitions can provide plain english names for property list keys, making it easier to tell what a particular key is used for. For example, instead of seeing “NSJavaPath” displayed for that key in an Info.plist file, you’d instead see “Java classpaths”, which makes it a little more clear what exactly the purpose of that key is.
Choosing from a list of allowed values
Some property list keys only allow certain values to be entered for that key, or at least there may be some small set of values that are very commonly used for a particular key. Structure definitions can provide a list of such values and provide a pop-up list and autocompletion when editing such a key. For example, when editing the CFBundleTypeRoles key of a document type dictionary in an Info.plist file, the structure definition provides a list of commonly used values for this key, which are “Editor”, “Viewer”, “Shell”, and “None”, so that you don’t have to remember these values or look them up yourself.
Additionally, for some keys which require non-string values, the structure definition will display textual representations of these values which are much easier to choose from. For example, the “LSUIPresentationMode” key in an Info.plist file requires a number to be entered for its value. This number corresponds to the SystemUIMode typedef declared in MacApplication.h in the Carbon framework. Normally, you would need to figure out what numeric value to use for a given mode (e.g. 0 gives you the normal UI mode, 1 hides the menu bar but not the dock, 2 hides both the menu bark and the dock. etc.) and enter that yourself. Using a structure definition, you will instead see choices such as “Normal”, “Content hidden”, “All hidden”, etc., and selecting one of those choices will set the numeric value to the appropriate number behind the scenes.
Structure definitions can provide default values for particular keys and object types. When you create a new object in your property list, it will automatically be populated with a sensible default value, rather than just being blank and leaving you to guess what type of information you might need to enter. Also, newly created dictionaries will be automatically populated with keys that are either required or present by default, so you don’t accidentally forget to include a required key for that dictionary.
A structure definition can also specify that a particular item or key be displayed as a different type, using PlistEdit Pro’s formatters (the same as you can assign using the “View As” submenu in the Edit menu). For example, if a four character code is being stored in a Number object as a 32 bit integer value, the structure definition can specify that that value should be display using the OSType formatter. This will result in you seeing the actual four character code rather than a very large plain numeric value, which isn’t particularly useful. Note: this functionality is only supported by PlistEdit Pro, and not by Apple’s Property List Editor or Xcode.
Identifying keys for dictionaries
A structure definition can specify that the value stored under a particular key should be used to identify a dictionary, making it easier to browse through a list of dictionaries to find the one you’re looking for. ßFor example, when looking at the list of document types stored under the CFBundleDocumentTypes key, each dictionary in that list has a CFBundleTypeName key which specifies the name of that document type. The Info.plist structure definition specifies this key as being the identifying key for document type dictionaries. When you look at this list in PlistEdit Pro using the Info.plist structure definition, each document type’s name will be displayed in the same row as the dictionary, making it easy to find a particular document type without having to expand each dictionary looking for the one whose name matches what you’re looking for. This is similar to the functionality provide by the “View By Subkey” command, only it’s done automatically when viewing a property list when using a structure definition.
A property list structure definition is made up mainly of a list of property list classes. Each class describes a particular kind of property list object and how it should be displayed when editing. Every structure definition has a special class named “root”, which specifies what the root object of the property list should look like, what keys it supports, and so forth. The root class then determines what classes should be used for its children. The children’s classes in turn specify what class should be used for their children, and so on down the hierarchy. When using a structure definition, you’ll notice that for many items, instead of the basic types like “Array”, “Boolean”, etc., you will instead see the name of the class that has been assigned to that item by the definition
In the example above, the Info.plist structure definition’s root class specifies that the object under the “Document types” key should be assigned the “DocumentTypeArray” class. The “DocumentTypeArray” class specifies that all its children should be assigned the “DocumentTypeDict” class, and then the “DocumentTypeDict” class specifies what should be used for its various child keys.
The most important piece of information for a class is what basic type should be used for property list objects that are assigned that clas. This can be one of the seven basic property list types: Array, Boolean, Data, Date, Dictionary, Number or String, as well as a Variant Dictionary type that will be explained a little later. The “root” class is typically a dictionary, though it can sometimes be an array as well. Depending on what type of object a class represents, the class will have different attributes that specify how that type of object should be treated when viewing and editing it. Note that currently, there is no way for one class to “subclass” another and inherit its properties.
If you wish to create your own custom structure definition, simply choose “New Definition” from the Definition menu, and a new document will be created with a single basic definition ready for you to edit. When you’ve performed your edits and wish to save, the file will be saved by default in ~/Library/Application Support/PlistEdit Pro/Structure Definitions. This way, they will automatically be loaded and usable by PlistEdit Pro at launch time.
PlistEdit Pro offers a full, custom interface for editing property list structure definitions. The easiest way to open an installed structure definition file is to go to the Definitions tab of the preferences window and double click the definition you would like to view/edit.
The editor window can be divided up into four basic areas:
If you edit and save an installed structure definition, the changes will take effect immediately in any open property list documents, so if you’re creating your own structure definition using PlistEdit Pro, you can “debug” your changes without having to close and reopen a document or quit and relaunch PlistEdit Pro.
When selecting a class whose type is a string, number, boolean, data, or date, you will see the controls above which allow you to edit the class.
When selecting a dictionary element, you will see the controls above for editing the definition element.
Underneath those controls is a table that lets you specify how to handle one or more specifc keys stored in this type of dictionary. Each row has the following attributes:
When selecting an array element, you will see the controls above for editing the definition element.
A variant dictionary type allows you to treate a dictionary differently based on its content. A variant dictionary type contains a list of one or more dictionary classes defined elsewhere in the structure definition. When a dictionary’s class is determined to be a variant dictionary, PlistEdit Pro will search through the variants and try to determine which variant is most applicable to the dictionary. This search is based on the “Variant key” and “Variant value” that is given for each dictionary class. To determine which variant to use, PlistEdit Pro evaluates each variant in order:
As an example of how a variant dictionary might be used, imagine you have a list of dictionaries, and each dictionary has a key named “class” which specifies a class name for that dictionary. For each possible class, you could create a dictionary type that would define the keys and values that apply to that class. For each dictionary type, you would specify “class” as the variant key for that dictionary type, and then the class name as the variant value. Finally, you would create a variant dictionary type and add a variant for each dictionary type you had created. Then, when one of these dictionaries was assigned your variant dictionary as its type, its “class” value would determine which dictionary type was used for that particular dictionary.
Structure definitions were introduced by Xcode 3.0 and are implemented as Xcode plugin files. Initially, these were plain XML files with a .xcodeplugin file extension, but then starting in Xcode 5, they changed to being full fledged code bundles with an extension of .dvtplugin. PlistEdit Pro supports both types of plugins, but can only read .dvtplugin style structure definitions, whereas it can both read and write .xcodeplugin style definitions. This means that definition files that ship with Xcode can be used by PlistEdit Pro, but not vice versa.
Xcode stores its structure definition plugins inside the Xcode.app application bundle, in Xcode.app/Contents/PlugIns, and will also read .dvtplugin style definitions stored in ~/Library/Application Support/Developer/Shared/Xcode/Plug-ins.
PlistEdit Pro ships with several of its own built-in .xcodeplugin structure definitions which are located inside its own application bundle. These structure definitions will only show up in PlistEdit Pro, and not Xcode or Property List Editor. PlistEdit Pro will also read definition files from ~/Application Support/PlistEdit Pro/Structure Definitions, which will be used as the default save location for new definition files created by you.
You can see what structure definitions you have installed by going to the Definitions tab in the preferences window of PlistEdit Pro.
￼ All installed structure definitions will be displayed in the Definitions table on the left. Note that a single plugin file can contain multiple definitions, such PlistEdit Pro’s built-in definitions for Applescript .scriptSuite and .scriptTerminology files, which are both stored in the same plugin file. On the right you will see the following information for the selected structure definition:
Note that if more than one copy of a particular structure definiton is present (based on the “identifier” field of the definition), PlistEdit Pro will only list one copy of the structure definition. Definitions installed in the user’s home folder take precedence over PlistEdit Pro built-in definitions, which in turn take precedence over Xcode built-in definitions.
PlistEdit Pro provides several ways to customize the program to the way you work. You can access these preferences by selecting the Preferences menu item in the PlistEdit Pro menu, or by pressing command-comma.
This tab displays all the structure definitions that are installed on your system. Refer to “Managing installed structure definitions” for more details on this tab.
This tab contains settings that affect property list browsers. When creating a new browser from a folder, or adding new items to an existing browser window, you can tell PlistEdit Pro what file extensions to scan the newly added folder for. Only files that match an extension in the list will be added. PlistEdit Pro can also read the ‘plst’ resource from the resource fork of a file (used by non-bundled Carbon applications). Checking the “Scan resource forks” checkbox will add any file that has a resource fork with a ‘plst’ resource whose ID is 0. Be aware that enabling this option can cause the scanning process to take significantly longer.
PlistEdit Pro provides tools for automatic workflows with property lists, through Applescript support and the pledit command line tool.
PlistEdit Pro allows you to automate tasks involving property lists by offering full Applescript support. For more information on how to script PlistEdit Pro, refer to its Applescript dictionary using Script Editor, as well as the example scripts which can be found on the PlistEdit Pro website.
PlistEdit Pro also provides a command line tool, pledit, which allows you to open property lists in PlistEdit Pro from the command line and shell scripts. You can open any number of existing property list files by passing them as arguments on the command line:
% pledit ~/Library/Preferences/com.apple.finder.plist % pledit MyApp.app/Contents/Resources/*.plist
pledit can also read property list data from stdin and open the data up as a new document in PlistEdit Pro:
% ibtool --export keypaths.plist MainMenu.nib | pledit % hdiutil imageinfo -plist MyDiskImage.dmg | pledit
The first time you open PlistEdit Pro with a new version of pledit, it will ask you if you want to install the tool, which requires an admin password and installs in /usr/bin. You can also install the tool later via the preferences window.
PlistEdit Pro requires macOS 10.9 or later. You may try out PlistEdit Pro for a free trial period of 14 days. After that period, you will still be able to open files with PlistEdit Pro, but will not be able to save any changes. PlistEdit Pro is $29.95 (US dollars) and can be purchased online with a credit card, debit card, or PayPal at our web store.
Free e-mail support is provided for users of PlistEdit Pro. If you have any problems, questions, feature requests, or other feedback, please send an e-mail to firstname.lastname@example.org . Please be sure to include what version of PlistEdit Pro, and what version of macOS you are running.
Version 1.9 (released 9/25/2018)
Version 1.8.7 (released 6/26/2017)
Version 1.8.6 (released 6/22/2017)
Version 1.8.5 (released 11/16/2016)
Version 1.8.4 (released 10/28/2016)
Version 1.8.3 (released 02/10/2016)
Version 1.8.2 (released 09/25/2015)
Version 1.8.1 (released 12/17/2014)
Version 1.8 (released 10/10/2014)
Version 1.7.4 (released 07/11/2012)
Version 1.7.3 (released 12/05/2011)
Version 1.7.2 (released 11/15/2011)
Version 1.7.1 (released 11/09/2011)
Version 1.7 (released 09/15/2011)
Version 1.6 (released 01/28/2011)
Version 1.5 (released 10/31/2009)
Version 1.4.2 (released 08/25/2009)
Version 1.4.1 (released 07/24/2008)
Version 1.4 (released 04/17/2008)
Version 1.3.1 (released 11/02/2007)
Version 1.3 (released 10/10/2006)
Version 1.2.1 (released 06/05/2006)
Version 1.2 (released 06/22/2005)
Version 1.1.2 (released 04/25/2005)
Version 1.1.1 (released 01/08/2005)
Version 1.1 (released 08/10/2004)
Version 1.0.1 (released 3/10/2004)