First version

Author: LachlanArthur

Diff for: .editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = false
+insert_final_newline = false

Diff for: .gitignore

@@ -0,0 +1,2 @@
+node_modules
+pkg

Diff for: jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+	preset: 'ts-jest',
+	testEnvironment: 'node',
+	globals: {
+		'ts-jest': {
+			warnOnly: true,
+			isolatedModules: true,
+		},
+	},
+};

Diff for: package.json

@@ -0,0 +1,37 @@
+{
+	"name": "php-serialized-data-js",
+	"version": "1.0.0",
+	"repository": "https://github.com/LachlanArthur/php-serialized-data-js",
+	"author": "LachlanArthur",
+	"license": "MIT",
+	"scripts": {
+		"publish-pkg": "pika publish --no-tests",
+		"test": "jest",
+		"build": "pika build",
+		"version": "npm run build"
+	},
+	"@pika/pack": {
+		"pipeline": [
+			[
+				"@pika/plugin-ts-standard-pkg"
+			],
+			[
+				"@pika/plugin-build-node"
+			],
+			[
+				"@pika/plugin-build-web"
+			]
+		]
+	},
+	"devDependencies": {
+		"@pika/pack": "^0.5.0",
+		"@pika/plugin-build-node": "^0.9.2",
+		"@pika/plugin-build-web": "^0.9.2",
+		"@pika/plugin-ts-standard-pkg": "^0.9.2",
+		"@types/jest": "^25.2.1",
+		"jest": "^25.4.0",
+		"ts-jest": "^25.4.0",
+		"typescript": "^3.8.3"
+	},
+	"dependencies": {}
+}

Diff for: readme.md

@@ -0,0 +1,60 @@
+# php-serialized-data
+
+Parse PHP serialized data with JS
+
+PHP's `serialize` function doesn't have a spec, so I used the handy [Kaitai Struct spec](https://formats.kaitai.io/php_serialized_value/index.html) as reference instead
+
+## Usage
+
+```js
+import { parse } from 'php-serialized-data';
+
+const data = parse( 'O:8:"stdClass":1:{s:3:"foo";s:3:"bar";}' );
+
+/*
+ObjectToken(
+  className: 'stdClass'
+  value: Map [
+    [ StringToken( 'foo' ), StringToken( 'bar' ) ],
+  ]
+)
+*/
+```
+
+It even works with multi-byte data like emoji:
+
+```js
+import { parse } from 'php-serialized-data';
+
+const data = parse( 's:4:"🐊";' );
+
+/*
+StringToken( '🐊' )
+*/
+```
+
+## Supports
+
+- Null
+- Integer
+- Float
+  - Infinity
+  - NaN
+  - Scientific notation
+- String
+  - Multi-byte (e.g. emoji)
+- Boolean
+- Array
+- Object
+  - Classes
+  - Custom Objects (contain arbitrary serialized data. e.g. `SplDoublyLinkedList`)
+- Object Reference
+- Value Reference
+
+## TODO
+
+- Dereference object & value references
+  - Also circular references
+- Output conversion to plain JS types
+  - Nulls in private/protected class property names
+- Throw on trailing data

Diff for: src/index.ts

@@ -0,0 +1 @@
+export { PHPTypes, parse } from './parse';

Diff for: src/parse.spec.ts

@@ -0,0 +1,183 @@
+import { parse, PHPTypes } from './parse';
+
+describe( 'Parser', () => {
+
+	test( 'CustomObject Empty', () => {
+		const [ token, increment ] = parse( 'C:9:"ClassName":0:{}' );
+		expect( token ).toEqual( new PHPTypes.PHPCustomObject( '', 'ClassName' ) );
+		expect( increment ).toBe( 20 );
+	} );
+
+	test( 'CustomObject Simple', () => {
+		const [ token, increment ] = parse( 'C:9:"ClassName":15:{serialized data}' );
+		expect( token ).toEqual( new PHPTypes.PHPCustomObject( 'serialized data', 'ClassName' ) );
+		expect( increment ).toBe( 36 );
+	} );
+
+	test( 'Null', () => {
+		const [ token, increment ] = parse( 'N;' );
+		expect( token ).toEqual( new PHPTypes.PHPNull() );
+		expect( increment ).toBe( 2 );
+	} );
+
+	test( 'Object Empty', () => {
+		const [ token, increment ] = parse( 'O:8:"stdClass":0:{}' );
+		expect( token ).toEqual( new PHPTypes.PHPObject( new Map(), 'stdClass' ) );
+		expect( increment ).toBe( 19 );
+	} );
+
+	test( 'Object Simple', () => {
+		const [ token, increment ] = parse( 'O:8:"stdClass":1:{s:3:"foo";s:3:"bar";}' );
+		expect( token ).toEqual( new PHPTypes.PHPObject(
+			new Map( [
+				[ new PHPTypes.PHPString( 'foo' ), new PHPTypes.PHPString( 'bar' ) ]
+			] ),
+			'stdClass'
+		) );
+		expect( increment ).toBe( 39 );
+	} );
+
+	test( 'Object Nested', () => {
+		const [ token, increment ] = parse( 'O:8:"stdClass":2:{s:1:"0";O:8:"stdClass":1:{s:1:"0";s:3:"foo";}s:1:"1";O:8:"stdClass":1:{s:1:"0";s:3:"bar";}}' );
+		expect( token ).toEqual( new PHPTypes.PHPObject(
+			new Map( [
+				[ new PHPTypes.PHPString( '0' ), new PHPTypes.PHPObject(
+					new Map( [ [ new PHPTypes.PHPString( '0' ), new PHPTypes.PHPString( 'foo' ) ] ] ),
+					'stdClass'
+				) ],
+				[ new PHPTypes.PHPString( '1' ), new PHPTypes.PHPObject(
+					new Map( [ [ new PHPTypes.PHPString( '0' ), new PHPTypes.PHPString( 'bar' ) ] ] ),
+					'stdClass'
+				) ],
+			] ),
+			'stdClass'
+		) );
+		expect( increment ).toBe( 109 );
+	} );
+
+	test( 'Reference', () => {
+		const [ token, increment ] = parse( 'R:1;' );
+		expect( token ).toEqual( new PHPTypes.PHPReference( 1 ) );
+		expect( increment ).toBe( 4 );
+	} );
+
+	test( 'String Empty', () => {
+		const [ token, increment ] = parse( 's:0:"";' );
+		expect( token ).toEqual( new PHPTypes.PHPString( '' ) );
+		expect( increment ).toBe( 7 );
+	} );
+
+	test( 'String Complicated', () => {
+		const [ token, increment ] = parse( 's:103:"This text - "s:38:"She exclaimed "Hello?" into the phone.";" - is an example of a serialized PHP value.";' );
+		expect( token ).toEqual( new PHPTypes.PHPString( 'This text - "s:38:"She exclaimed "Hello?" into the phone.";" - is an example of a serialized PHP value.' ) );
+		expect( increment ).toBe( 112 );
+	} );
+
+	test( 'String Emoji', () => {
+		const [ token, increment ] = parse( 's:4:"🐊";' );
+		expect( token ).toEqual( new PHPTypes.PHPString( '🐊' ) );
+		expect( increment ).toBe( 9 );
+	} );
+
+	test( 'Array Empty', () => {
+		const [ token, increment ] = parse( 'a:0:{}' );
+		expect( token ).toEqual( new PHPTypes.PHPArray( new Map( [] ) ) );
+		expect( increment ).toBe( 6 );
+	} );
+
+	test( 'Array Simple', () => {
+		const [ token, increment ] = parse( 'a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}' );
+		expect( token ).toEqual( new PHPTypes.PHPArray( new Map( [
+			[ new PHPTypes.PHPInteger( 0 ), new PHPTypes.PHPString( 'foo' ) ],
+			[ new PHPTypes.PHPInteger( 1 ), new PHPTypes.PHPString( 'bar' ) ],
+		] ) ) );
+		expect( increment ).toBe( 34 );
+	} );
+
+	test( 'Array Nested', () => {
+		const [ token, increment ] = parse( 'a:2:{i:0;a:1:{i:0;s:3:"foo";}i:1;a:1:{i:0;s:3:"bar";}}' );
+		expect( token ).toEqual( new PHPTypes.PHPArray( new Map( [
+			[ new PHPTypes.PHPInteger( 0 ), new PHPTypes.PHPArray( new Map( [
+				[ new PHPTypes.PHPInteger( 0 ), new PHPTypes.PHPString( 'foo' ) ],
+			] ) ) ],
+			[ new PHPTypes.PHPInteger( 1 ), new PHPTypes.PHPArray( new Map( [
+				[ new PHPTypes.PHPInteger( 0 ), new PHPTypes.PHPString( 'bar' ) ],
+			] ) ) ],
+		] ) ) );
+		expect( increment ).toBe( 54 );
+	} );
+
+	test( 'Boolean False', () => {
+		const [ token, increment ] = parse( 'b:0;' );
+		expect( token ).toEqual( new PHPTypes.PHPBoolean( false ) );
+		expect( increment ).toBe( 4 );
+	} );
+
+	test( 'Boolean True', () => {
+		const [ token, increment ] = parse( 'b:1;' );
+		expect( token ).toEqual( new PHPTypes.PHPBoolean( true ) );
+		expect( increment ).toBe( 4 );
+	} );
+
+	test( 'Float Positive', () => {
+		const [ token, increment ] = parse( 'd:12.34;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBeCloseTo( 12.34 );
+		expect( increment ).toBe( 8 );
+	} );
+
+	test( 'Float Negative', () => {
+		const [ token, increment ] = parse( 'd:-12.34;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBeCloseTo( -12.34 );
+		expect( increment ).toBe( 9 );
+	} );
+
+	test( 'Float Scientific Notation Positive', () => {
+		const [ token, increment ] = parse( 'd:1.1111111111111112E+69;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBeCloseTo( 1.1111111111111112e+69 );
+		expect( increment ).toBe( 25 );
+	} );
+
+	test( 'Float Scientific Notation Negative', () => {
+		const [ token, increment ] = parse( 'd:-1.1111111111111112E+69;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBeCloseTo( -1.1111111111111112e+69 );
+		expect( increment ).toBe( 26 );
+	} );
+
+	test( 'Float Infinity Positive', () => {
+		const [ token, increment ] = parse( 'd:INF;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBe( Infinity );
+		expect( increment ).toBe( 6 );
+	} );
+
+	test( 'Float Infinity Negative', () => {
+		const [ token, increment ] = parse( 'd:-INF;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBe( -Infinity );
+		expect( increment ).toBe( 7 );
+	} );
+
+	test( 'Float NaN', () => {
+		const [ token, increment ] = parse( 'd:NAN;' );
+		expect( token ).toBeInstanceOf( PHPTypes.PHPFloat );
+		expect( token.value ).toBeNaN();
+		expect( increment ).toBe( 6 );
+	} );
+
+	test( 'Integer Positive', () => {
+		const [ token, increment ] = parse( 'i:1234;' );
+		expect( token.value ).toBe( 1234 );
+		expect( increment ).toBe( 7 );
+	} );
+
+	test( 'Integer Negative', () => {
+		const [ token, increment ] = parse( 'i:-1234;' );
+		expect( token.value ).toBe( -1234 );
+		expect( increment ).toBe( 8 );
+	} );
+
+} );